@goscribe/server 1.0.11 → 1.1.1

package/src/routers/chat.ts

@@ -220,18 +220,7 @@ export const chat = router({
                 }
             });
             // Notify via Pusher
-            await PusherService.emitChannelEvent(chat.channelId, "edit_message", {
-                chatId: updatedChat.id,
-                channelId: updatedChat.channelId,
-                userId: updatedChat.userId,
-                message: input.message,
-                updatedAt: updatedChat.updatedAt,
-                user: {
-                    id: ctx.session.user.id,
-                    name: updatedChat.user?.name,
-                    image: updatedChat.user?.image,
-                },
-            });
+            await PusherService.emitChannelEvent(chat.channelId, "edit_message", updatedChat);
             return updatedChat;
         }),
     deleteMessage: authedProcedure
@@ -259,17 +248,7 @@ export const chat = router({
                 where: { id: input.chatId },
             });
             // Notify via Pusher
-            await PusherService.emitChannelEvent(chat.channelId, "delete_message", {
-                chatId: chat.id,
-                channelId: chat.channelId,
-                userId: chat.userId,
-                deletedAt: new Date().toISOString(),
-                user: {
-                    id: ctx.session.user.id,
-                    name: chat.user?.name,
-                    image: chat.user?.image,
-                },
-            });
+            await PusherService.emitChannelEvent(chat.channelId, "delete_message", chat);
             return { success: true };
         }),
 });

package/src/routers/flashcards.ts

@@ -4,6 +4,7 @@ import { router, authedProcedure } from '../trpc.js';
 import createInferenceService from '../lib/inference.js';
 import { aiSessionService } from '../lib/ai-session.js';
 import PusherService from '../lib/pusher.js';
+import { createFlashcardProgressService } from '../services/flashcard-progress.service.js';
 // Prisma enum values mapped manually to avoid type import issues in ESM
 const ArtifactType = {
   STUDY_GUIDE: 'STUDY_GUIDE',
@@ -38,13 +39,30 @@ export const flashcards = router({
       const set = await ctx.db.artifact.findFirst({
         where: { workspaceId: input.workspaceId, type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } },
         include: {
-          flashcards: true,
+          flashcards: {
+            include: {
+              progress: {
+                where: {
+                  userId: ctx.session.user.id,
+                },
+              },
+            }
+          },
+
         },
         orderBy: { updatedAt: 'desc' },
       });
       if (!set) throw new TRPCError({ code: 'NOT_FOUND' });
       return set.flashcards;
     }),
+  isGenerating: authedProcedure
+    .input(z.object({ workspaceId: z.string() }))
+    .query(async ({ ctx, input }) => {
+      const artifact = await ctx.db.artifact.findFirst({
+        where: { workspaceId: input.workspaceId, type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } }, orderBy: { updatedAt: 'desc' },
+      });
+      return artifact?.generating;
+    }),
   createCard: authedProcedure
     .input(z.object({
       workspaceId: z.string(),
@@ -137,14 +155,13 @@ export const flashcards = router({
       });
       if (!workspace) throw new TRPCError({ code: 'NOT_FOUND' });
 
-      // Pusher start
-      await PusherService.emitTaskComplete(input.workspaceId, 'flash_card_load_start', { source: 'prompt' });
       const flashcardCurrent = await ctx.db.artifact.findFirst({
         where: {
           workspaceId: input.workspaceId,
           type: ArtifactType.FLASHCARD_SET,
         },
         select: {
+          id: true,
           flashcards: true,
         },
         orderBy: {
@@ -152,6 +169,13 @@ export const flashcards = router({
         },
       });
 
+      try {
+      await ctx.db.artifact.update({
+        where: { id: flashcardCurrent?.id },
+        data: { generating: true, generatingMetadata: { quantity: input.numCards, difficulty: input.difficulty.toLowerCase() } },
+      });
+
+      await PusherService.emitTaskComplete(input.workspaceId, 'flash_card_info', { status: 'generating', numCards: input.numCards, difficulty: input.difficulty });
 
       const formattedPreviousCards = flashcardCurrent?.flashcards.map((card) => ({
         front: card.front,
@@ -169,22 +193,6 @@ export const flashcards = router({
 
       The user has also left you this prompt: ${input.prompt}
       `
-      // Init AI session and seed with prompt as instruction
-      const session = await aiSessionService.initSession(input.workspaceId, ctx.session.user.id);
-      await aiSessionService.setInstruction(session.id, partialPrompt);
-
-      await aiSessionService.startLLMSession(session.id);
-      
-      const currentCards = flashcardCurrent?.flashcards.length || 0;
-      const newCards = input.numCards - currentCards;
-
-      // Generate
-      await PusherService.emitTaskComplete(input.workspaceId, 'flash_card_info', { status: 'generating', numCards: input.numCards, difficulty: input.difficulty });
-      const content = await aiSessionService.generateFlashcardQuestions(session.id, input.numCards, input.difficulty);
-
-      // Previous cards
-
-      // Create artifact
       const artifact = await ctx.db.artifact.create({
         data: {
           workspaceId: input.workspaceId,
@@ -199,11 +207,17 @@ export const flashcards = router({
           },
         },
       });
+      
+      const currentCards = flashcardCurrent?.flashcards.length || 0;
+      const newCards = input.numCards - currentCards;
+
+
+      // Generate
+      const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, ctx.session.user.id, input.numCards, input.difficulty);
 
-      // Parse and create cards
       let createdCards = 0;
       try {
-        const flashcardData = JSON.parse(content);
+        const flashcardData: any = content;
         for (let i = 0; i < Math.min(flashcardData.length, input.numCards); i++) {
           const card = flashcardData[i];
           const front = card.term || card.front || card.question || card.prompt || `Question ${i + 1}`;
@@ -243,10 +257,80 @@ export const flashcards = router({
       // Pusher complete
       await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
 
-      // Cleanup AI session (best-effort)
-      aiSessionService.deleteSession(session.id);
-
       return { artifact, createdCards };
+
+    } catch (error) {
+      await ctx.db.artifact.update({ where: { id: flashcardCurrent?.id }, data: { generating: false } });
+      await PusherService.emitError(input.workspaceId, `Failed to generate flashcards: ${error}`, 'flash_card_generation');
+      throw error;
+    }
+    }),
+
+  // Record study attempt
+  recordStudyAttempt: authedProcedure
+    .input(z.object({
+      flashcardId: z.string().cuid(),
+      isCorrect: z.boolean(),
+      confidence: z.enum(['easy', 'medium', 'hard']).optional(),
+      timeSpentMs: z.number().optional(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const service = createFlashcardProgressService(ctx.db);
+      return service.recordStudyAttempt({
+        userId: ctx.userId,
+        ...input,
+      });
+    }),
+
+  // Get progress for a flashcard set
+  getSetProgress: authedProcedure
+    .input(z.object({ artifactId: z.string().cuid() }))
+    .query(async ({ ctx, input }) => {
+      const service = createFlashcardProgressService(ctx.db);
+      return service.getSetProgress(ctx.userId, input.artifactId);
+    }),
+
+  // Get flashcards due for review
+  getDueFlashcards: authedProcedure
+    .input(z.object({ workspaceId: z.string() }))
+    .query(async ({ ctx, input }) => {
+      const service = createFlashcardProgressService(ctx.db);
+
+      return service.getDueFlashcards(ctx.userId, input.workspaceId);
+    }),
+
+  // Get statistics for a flashcard set
+  getSetStatistics: authedProcedure
+    .input(z.object({ artifactId: z.string().cuid() }))
+    .query(async ({ ctx, input }) => {
+      const service = createFlashcardProgressService(ctx.db);
+      return service.getSetStatistics(ctx.userId, input.artifactId);
+    }),
+
+  // Reset progress for a flashcard
+  resetProgress: authedProcedure
+    .input(z.object({ flashcardId: z.string().cuid() }))
+    .mutation(async ({ ctx, input }) => {
+      const service = createFlashcardProgressService(ctx.db);
+      return service.resetProgress(ctx.userId, input.flashcardId);
+    }),
+
+  // Bulk record study session
+  recordStudySession: authedProcedure
+    .input(z.object({
+      attempts: z.array(z.object({
+        flashcardId: z.string().cuid(),
+        isCorrect: z.boolean(),
+        confidence: z.enum(['easy', 'medium', 'hard']).optional(),
+        timeSpentMs: z.number().optional(),
+      })),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const service = createFlashcardProgressService(ctx.db);
+      return service.recordStudySession({
+        userId: ctx.userId,
+        ...input,
+      });
     }),
 });