@goscribe/server 1.0.7 → 1.0.9

package/src/routers/studyguide.ts

@@ -0,0 +1,144 @@
+import { z } from 'zod';
+import { TRPCError } from '@trpc/server';
+import { router, authedProcedure } from '../trpc.js';
+import { title } from 'node:process';
+
+// Mirror Prisma enum to avoid direct type import
+const ArtifactType = {
+  STUDY_GUIDE: 'STUDY_GUIDE',
+} as const;
+
+const initializeEditorJsEmptyBlock = () => ({
+  time: Date.now(),
+  blocks: [
+    {
+      id: 'initial',
+      type: 'paragraph',
+      data: { text: 'Start writing your study guide...' },
+    },
+  ],
+  version: '2.27.0',
+});
+
+export const studyguide = router({
+  // Get latest study guide for a workspace or a specific study guide by ID
+  get: authedProcedure
+    .input(
+      z.object({
+        workspaceId: z.string(),
+      })
+    )
+    .query(async ({ ctx, input }) => {
+      // by studyGuideId (artifact id)
+      let artifact = await ctx.db.artifact.findFirst({
+        where: {
+          workspaceId: input.workspaceId!,
+          type: ArtifactType.STUDY_GUIDE,
+          workspace: { ownerId: ctx.session.user.id },
+        },
+        include: {
+          versions: { orderBy: { version: 'desc' }, take: 1 },
+        },
+      });
+
+      console.log('artifact', artifact);
+      if (!artifact) {
+        artifact = await ctx.db.artifact.create({
+          data: {
+            workspaceId: input.workspaceId,
+            type: ArtifactType.STUDY_GUIDE,
+            title: 'Study Guide',
+            createdById: ctx.session.user.id,
+            versions: {
+              create: {
+                content: `${JSON.stringify(initializeEditorJsEmptyBlock())}`,
+                version: 1,
+                createdById: ctx.session.user.id,
+              }
+            }
+          },
+          include: {
+            versions: { orderBy: { version: 'desc' }, take: 1 },
+          }
+        });
+      }
+      const latestVersion = artifact.versions[0] ?? null;
+      return { artifactId: artifact.id, title: artifact.title, latestVersion };
+    }),
+
+  // Edit study guide content by creating a new version, or create if doesn't exist
+  edit: authedProcedure
+    .input(
+      z.object({
+        workspaceId: z.string(),
+        studyGuideId: z.string().optional(),
+        content: z.string().min(1),
+        data: z.record(z.string(), z.unknown()).optional(),
+        title: z.string().min(1).optional(),
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      let artifact;
+      
+      if (input.studyGuideId) {
+        // Try to find existing study guide
+        artifact = await ctx.db.artifact.findFirst({
+          where: {
+            id: input.studyGuideId,
+            type: ArtifactType.STUDY_GUIDE,
+            workspace: { ownerId: ctx.session.user.id },
+          },
+        });
+      } else {
+        // Find by workspace if no specific studyGuideId provided
+        artifact = await ctx.db.artifact.findFirst({
+          where: {
+            workspaceId: input.workspaceId,
+            type: ArtifactType.STUDY_GUIDE,
+            workspace: { ownerId: ctx.session.user.id },
+          },
+        });
+      }
+      
+      // If no study guide found, create a new one
+      if (!artifact) {
+        artifact = await ctx.db.artifact.create({
+          data: {
+            workspaceId: input.workspaceId,
+            type: ArtifactType.STUDY_GUIDE,
+            title: 'Study Guide',
+            createdById: ctx.session.user.id,
+          },
+        });
+      }
+
+      const last = await ctx.db.artifactVersion.findFirst({
+        where: { artifactId: artifact.id },
+        orderBy: { version: 'desc' },
+      });
+
+      if (input.title && input.title !== artifact.title) {
+        console.log('rename')
+        await ctx.db.artifact.update({
+          where: { id: artifact.id },
+          data: { title: input.title },
+        });
+      }
+      
+      const nextVersion = (last?.version ?? 0) + 1;
+
+      const version = await ctx.db.artifactVersion.create({
+        data: {
+          artifactId: artifact.id,
+          content: input.content,
+          data: input.data as any,
+          version: nextVersion,
+          createdById: ctx.session.user.id,
+        },
+      });
+
+      return { artifactId: artifact.id, version };
+    }),
+});
+
+

package/src/routers/worksheets.ts

@@ -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 = {
@@ -13,48 +15,113 @@ const Difficulty = {
   HARD: 'HARD',
 } as const;
 
+const QuestionType = {
+  MULTIPLE_CHOICE: 'MULTIPLE_CHOICE',
+  TEXT: 'TEXT',
+  NUMERIC: 'NUMERIC',
+  TRUE_FALSE: 'TRUE_FALSE',
+  MATCHING: 'MATCHING',
+  FILL_IN_THE_BLANK: 'FILL_IN_THE_BLANK',
+} as const;
+
 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 as any)) : {} as any;
+          return {
+            ...q,
+            meta: {
+              ...existingMeta,
+              completed: p.completed,
+              userAnswer: p.userAnswer,
+              completedAt: p.completedAt,
+            },
+          } as typeof q;
+        }),
+      }));
+
+      return merged as any;
     }),
 
   // Create a worksheet set
-  createWorksheet: 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 as any,
+          estimatedTime: input.estimatedTime,
           createdById: ctx.session.user.id,
+          questions: problems ? {
+            create: problems.map((problem, index) => ({
+              prompt: problem.question,
+              answer: problem.answer,
+              type: problem.type as any,
+              order: index,
+              meta: problem.options ? { options: problem.options } : undefined,
+            })),
+          } : undefined,
+        },
+        include: {
+          questions: true,
         },
       });
     }),
 
   // Get a worksheet with its questions
-  getWorksheet: authedProcedure
-    .input(z.object({ worksheetId: z.string().uuid() }))
+  get: authedProcedure
+    .input(z.object({ worksheetId: z.string() }))
     .query(async ({ ctx, input }) => {
       const worksheet = await ctx.db.artifact.findFirst({
         where: {
@@ -63,17 +130,46 @@ 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 as any)) : {} as any;
+          return {
+            ...q,
+            meta: {
+              ...existingMeta,
+              completed: p.completed,
+              userAnswer: p.userAnswer,
+              completedAt: p.completedAt,
+            },
+          } as typeof q;
+        }),
+      };
+
+      return merged as any;
     }),
 
   // Add a question to a worksheet
   createWorksheetQuestion: authedProcedure
     .input(z.object({
-      worksheetId: 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(),
@@ -88,6 +184,7 @@ export const worksheets = router({
           artifactId: input.worksheetId,
           prompt: input.prompt,
           answer: input.answer,
+          type: (input.type ?? QuestionType.TEXT) as any,
           difficulty: (input.difficulty ?? Difficulty.MEDIUM) as any,
           order: input.order ?? 0,
           meta: input.meta as any,
@@ -98,9 +195,10 @@ export const worksheets = router({
   // Update a question
   updateWorksheetQuestion: authedProcedure
     .input(z.object({
-      worksheetQuestionId: 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(),
@@ -115,6 +213,7 @@ export const worksheets = router({
         data: {
           prompt: input.prompt ?? q.prompt,
           answer: input.answer ?? q.answer,
+          type: (input.type ?? q.type) as any,
           difficulty: (input.difficulty ?? q.difficulty) as any,
           order: input.order ?? q.order,
           meta: (input.meta ?? q.meta) as any,
@@ -124,7 +223,7 @@ export const worksheets = router({
 
   // Delete a question
   deleteWorksheetQuestion: authedProcedure
-    .input(z.object({ worksheetQuestionId: z.string().uuid() }))
+    .input(z.object({ worksheetQuestionId: z.string() }))
     .mutation(async ({ ctx, input }) => {
       const q = await ctx.db.worksheetQuestion.findFirst({
         where: { id: input.worksheetQuestionId, artifact: { workspace: { ownerId: ctx.session.user.id } } },
@@ -134,16 +233,245 @@ export const worksheets = router({
       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 as any,
+            order: index,
+            meta: problem.options ? { options: problem.options } : undefined,
+          })),
+        });
+      }
+
+      // Process update data
+      const processedUpdateData = {
+        ...updateData,
+        difficulty: updateData.difficulty as any,
+      };
+
+      return ctx.db.artifact.update({
+        where: { id },
+        data: processedUpdateData,
+        include: {
+          questions: {
+            orderBy: { order: 'asc' },
+          },
+        },
+      });
+    }),
+
   // Delete a worksheet set and its questions
-  deleteWorksheet: authedProcedure
-      .input(z.object({ worksheetId: 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.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()) as any,
+          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()) as any,
+              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()) as any,
+                order: i,
+                meta: { type: 'TEXT' },
+              },
+            });
+          }
+        }
+      }
+
+      await PusherService.emitWorksheetComplete(input.workspaceId, artifact);
+      aiSessionService.deleteSession(session.id);
+
+      return { artifact };
+    }),
 });