@goscribe/server 1.0.8 → 1.0.10

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,6 +12,14 @@ 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
     list: authedProcedure
@@ -28,23 +38,76 @@ export const worksheets = router({
         });
         if (!worksheets)
             throw new TRPCError({ code: 'NOT_FOUND' });
-        return worksheets;
+        // 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
-    createWorksheet: authedProcedure
-        .input(z.object({ workspaceId: z.string(), 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,
             },
         });
     }),
@@ -59,10 +122,37 @@ export const worksheets = router({
                 workspace: { ownerId: ctx.session.user.id },
             },
             include: { questions: true },
+            orderBy: { updatedAt: 'desc' },
         });
         if (!worksheet)
             throw new TRPCError({ code: 'NOT_FOUND' });
-        return worksheet;
+        // 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
     createWorksheetQuestion: authedProcedure
@@ -70,6 +160,7 @@ export const worksheets = router({
         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(),
@@ -85,6 +176,7 @@ export const worksheets = router({
                 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,
@@ -97,6 +189,7 @@ export const worksheets = router({
         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(),
@@ -112,6 +205,7 @@ export const worksheets = router({
             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),
@@ -130,15 +224,231 @@ export const worksheets = router({
         await ctx.db.worksheetQuestion.delete({ where: { id: input.worksheetQuestionId } });
         return true;
     }),
-    // Delete a worksheet set and its questions
-    deleteWorksheet: authedProcedure
+    // 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
+    delete: authedProcedure
+        .input(z.object({ id: z.string() }))
         .mutation(async ({ ctx, input }) => {
         const deleted = await ctx.db.artifact.deleteMany({
-            where: { id: input.worksheetId, 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 };
+    }),
 });

package/dist/routers/workspace.d.ts

@@ -11,7 +11,37 @@ export declare const workspace: import("@trpc/server").TRPCBuiltRouter<{
     transformer: true;
 }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
     list: import("@trpc/server").TRPCQueryProcedure<{
-        input: void;
+        input: {
+            parentId?: string | undefined;
+        };
+        output: {
+            workspaces: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                ownerId: string;
+                title: string;
+                description: string | null;
+                folderId: string | null;
+                shareLink: string | null;
+            }[];
+            folders: {
+                name: string;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                ownerId: string;
+                parentId: string | null;
+            }[];
+        };
+        meta: object;
+    }>;
+    create: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            name: string;
+            description?: string | undefined;
+            parentId?: string | undefined;
+        };
         output: {
             id: string;
             createdAt: Date;
@@ -20,22 +50,22 @@ export declare const workspace: import("@trpc/server").TRPCBuiltRouter<{
             title: string;
             description: string | null;
             folderId: string | null;
-        }[];
+            shareLink: string | null;
+        };
         meta: object;
     }>;
-    create: import("@trpc/server").TRPCMutationProcedure<{
+    createFolder: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             name: string;
-            description?: string | undefined;
+            parentId?: string | undefined;
         };
         output: {
+            name: string;
             id: string;
             createdAt: Date;
             updatedAt: Date;
             ownerId: string;
-            title: string;
-            description: string | null;
-            folderId: string | null;
+            parentId: string | null;
         };
         meta: object;
     }>;
@@ -44,6 +74,42 @@ export declare const workspace: import("@trpc/server").TRPCBuiltRouter<{
             id: string;
         };
         output: {
+            folder: {
+                name: string;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                ownerId: string;
+                parentId: string | null;
+            } | null;
+            uploads: {
+                meta: import("@prisma/client/runtime/library").JsonValue | null;
+                name: string;
+                id: string;
+                createdAt: Date;
+                userId: string;
+                workspaceId: string;
+                mimeType: string;
+                size: number;
+                bucket: string | null;
+                objectKey: string | null;
+                url: string | null;
+                checksum: string | null;
+            }[];
+            artifacts: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                title: string;
+                description: string | null;
+                workspaceId: string;
+                type: import("@prisma/client").$Enums.ArtifactType;
+                isArchived: boolean;
+                difficulty: import("@prisma/client").$Enums.Difficulty | null;
+                estimatedTime: string | null;
+                createdById: string | null;
+            }[];
+        } & {
             id: string;
             createdAt: Date;
             updatedAt: Date;
@@ -51,6 +117,30 @@ export declare const workspace: import("@trpc/server").TRPCBuiltRouter<{
             title: string;
             description: string | null;
             folderId: string | null;
+            shareLink: string | null;
+        };
+        meta: object;
+    }>;
+    share: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            shareLink: string | null;
+        } | undefined;
+        meta: object;
+    }>;
+    join: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            shareLink: string;
+        };
+        output: {
+            id: string;
+            title: string;
+            description: string | null;
+            ownerId: string;
+            createdAt: Date;
+            updatedAt: Date;
         };
         meta: object;
     }>;
@@ -68,6 +158,7 @@ export declare const workspace: import("@trpc/server").TRPCBuiltRouter<{
             title: string;
             description: string | null;
             folderId: string | null;
+            shareLink: string | null;
         };
         meta: object;
     }>;
@@ -78,6 +169,30 @@ export declare const workspace: import("@trpc/server").TRPCBuiltRouter<{
         output: boolean;
         meta: object;
     }>;
+    getFolderInformation: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            folder: {
+                name: string;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                ownerId: string;
+                parentId: string | null;
+            };
+            parents: {
+                name: string;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                ownerId: string;
+                parentId: string | null;
+            }[];
+        };
+        meta: object;
+    }>;
     uploadFiles: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             id: string;
@@ -101,4 +216,44 @@ export declare const workspace: import("@trpc/server").TRPCBuiltRouter<{
         output: boolean;
         meta: object;
     }>;
+    uploadAndAnalyzeMedia: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workspaceId: string;
+            file: {
+                filename: string;
+                contentType: string;
+                size: number;
+                content: string;
+            };
+            generateStudyGuide?: boolean | undefined;
+            generateFlashcards?: boolean | undefined;
+            generateWorksheet?: boolean | undefined;
+        };
+        output: {
+            filename: string;
+            artifacts: {
+                studyGuide: any | null;
+                flashcards: any | null;
+                worksheet: any | null;
+            };
+        };
+        meta: object;
+    }>;
+    search: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            query: string;
+            limit?: number | undefined;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            ownerId: string;
+            title: string;
+            description: string | null;
+            folderId: string | null;
+            shareLink: string | null;
+        }[];
+        meta: object;
+    }>;
 }>>;