@goscribe/server 1.1.7 → 1.3.0

package/src/routers/flashcards.ts

@@ -1,18 +1,46 @@
 import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
-import { router, authedProcedure } from '../trpc.js';
+import { router, authedProcedure, verifiedProcedure,limitedProcedure  } from '../trpc.js';
 import createInferenceService from '../lib/inference.js';
 import { aiSessionService } from '../lib/ai-session.js';
 import PusherService from '../lib/pusher.js';
+import { notifyArtifactFailed, notifyArtifactReady } from '../lib/notification-service.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',
-  FLASHCARD_SET: 'FLASHCARD_SET',
-  WORKSHEET: 'WORKSHEET',
-  MEETING_SUMMARY: 'MEETING_SUMMARY',
-  PODCAST_EPISODE: 'PODCAST_EPISODE',
-} as const;
+import { ArtifactType } from '../lib/constants.js';
+import { workspaceAccessFilter } from '../lib/workspace-access.js';
+import inference from '../lib/inference.js';
+
+const typedAnswerGradeSchema = z.object({
+  isCorrect: z.boolean(),
+  confidence: z.number().min(0).max(1),
+  reason: z.string().min(1),
+  matchedAnswer: z.string().nullable(),
+});
+
+function normalizeAcceptedAnswers(answers?: string[]): string[] {
+  if (!answers || answers.length === 0) return [];
+
+  const seen = new Set<string>();
+  const normalized: string[] = [];
+
+  for (const answer of answers) {
+    const trimmed = answer.trim();
+    if (!trimmed) continue;
+    const key = trimmed.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    normalized.push(trimmed);
+  }
+
+  return normalized;
+}
+
+function extractFirstJsonObject(text: string): string | null {
+  const start = text.indexOf('{');
+  const end = text.lastIndexOf('}');
+  if (start === -1 || end === -1 || end <= start) return null;
+  return text.slice(start, end + 1);
+}
 
 export const flashcards = router({
   listSets: authedProcedure
@@ -37,7 +65,7 @@ export const flashcards = router({
     .input(z.object({ workspaceId: z.string() }))
     .query(async ({ ctx, input }) => {
       const set = await ctx.db.artifact.findFirst({
-        where: { workspaceId: input.workspaceId, type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } },
+        where: { workspaceId: input.workspaceId, type: ArtifactType.FLASHCARD_SET, workspace: workspaceAccessFilter(ctx.session.user.id) },
         include: {
           flashcards: {
             include: {
@@ -50,7 +78,7 @@ export const flashcards = router({
           },
 
         },
-        orderBy: { updatedAt: 'desc' },
+        orderBy: { createdAt: 'desc' },
       });
       if (!set) throw new TRPCError({ code: 'NOT_FOUND' });
       return set.flashcards;
@@ -59,23 +87,27 @@ export const flashcards = router({
     .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' },
+        where: { workspaceId: input.workspaceId, type: ArtifactType.FLASHCARD_SET, workspace: workspaceAccessFilter(ctx.session.user.id) },
+        orderBy: { createdAt: 'desc' },
       });
       return artifact?.generating;
     }),
-  createCard: authedProcedure
+  createCard: limitedProcedure
     .input(z.object({
       workspaceId: z.string(),
       front: z.string().min(1),
       back: z.string().min(1),
+      acceptedAnswers: z.array(z.string()).optional(),
       tags: z.array(z.string()).optional(),
       order: z.number().int().optional(),
     }))
     .mutation(async ({ ctx, input }) => {
       const set = await ctx.db.artifact.findFirst({
-        where: { type: ArtifactType.FLASHCARD_SET, workspace: {
-          id: input.workspaceId,
-        } },
+        where: {
+          type: ArtifactType.FLASHCARD_SET, workspace: {
+            id: input.workspaceId,
+          }
+        },
         include: {
           flashcards: true,
         },
@@ -87,6 +119,7 @@ export const flashcards = router({
           artifactId: set.id,
           front: input.front,
           back: input.back,
+          acceptedAnswers: normalizeAcceptedAnswers(input.acceptedAnswers),
           tags: input.tags ?? [],
           order: input.order ?? 0,
         },
@@ -98,12 +131,13 @@ export const flashcards = router({
       cardId: z.string(),
       front: z.string().optional(),
       back: z.string().optional(),
+      acceptedAnswers: z.array(z.string()).optional(),
       tags: z.array(z.string()).optional(),
       order: z.number().int().optional(),
     }))
     .mutation(async ({ ctx, input }) => {
       const card = await ctx.db.flashcard.findFirst({
-        where: { id: input.cardId, artifact: { type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } } },
+        where: { id: input.cardId, artifact: { type: ArtifactType.FLASHCARD_SET, workspace: workspaceAccessFilter(ctx.session.user.id) } },
       });
       if (!card) throw new TRPCError({ code: 'NOT_FOUND' });
       return ctx.db.flashcard.update({
@@ -111,17 +145,88 @@ export const flashcards = router({
         data: {
           front: input.front ?? card.front,
           back: input.back ?? card.back,
+          acceptedAnswers: input.acceptedAnswers ? normalizeAcceptedAnswers(input.acceptedAnswers) : card.acceptedAnswers,
           tags: input.tags ?? card.tags,
           order: input.order ?? card.order,
         },
       });
     }),
 
+  gradeTypedAnswer: authedProcedure
+    .input(z.object({
+      flashcardId: z.string().cuid(),
+      userAnswer: z.string().min(1),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const flashcard = await ctx.db.flashcard.findFirst({
+        where: {
+          id: input.flashcardId,
+          artifact: {
+            type: ArtifactType.FLASHCARD_SET,
+            workspace: workspaceAccessFilter(ctx.session.user.id),
+          },
+        },
+        select: {
+          id: true,
+          front: true,
+          back: true,
+          acceptedAnswers: true,
+        },
+      });
+
+      if (!flashcard) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Flashcard not found' });
+      }
+
+      const acceptedAnswers = [
+        flashcard.back,
+        ...normalizeAcceptedAnswers(flashcard.acceptedAnswers),
+      ];
+
+      const prompt = [
+        'Grade whether the student answer is semantically correct for the flashcard.',
+        '',
+        'Return ONLY valid JSON with this exact shape:',
+        '{"isCorrect": boolean, "confidence": number, "reason": string, "matchedAnswer": string | null}',
+        '',
+        'Rules:',
+        '- Accept synonyms, short paraphrases, and equivalent wording.',
+        '- Reject answers that are contradictory, unrelated, or materially incomplete.',
+        '- confidence must be from 0 to 1.',
+        '- reason must be under 160 characters.',
+        '- matchedAnswer must be the matched canonical/alias answer, or null if incorrect.',
+        '',
+        `Question: ${flashcard.front}`,
+        `Canonical answer: ${flashcard.back}`,
+        `Accepted aliases: ${JSON.stringify(acceptedAnswers)}`,
+        `Student answer: ${input.userAnswer}`,
+      ].join('\n');
+
+      try {
+        const response = await inference([{ role: 'user', content: prompt }]);
+        const content = response.choices?.[0]?.message?.content ?? '';
+        const jsonCandidate = extractFirstJsonObject(content);
+
+        if (!jsonCandidate) {
+          throw new Error('No JSON object found in grading response');
+        }
+
+        const parsed = JSON.parse(jsonCandidate);
+        return typedAnswerGradeSchema.parse(parsed);
+      } catch (error) {
+        throw new TRPCError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to grade typed answer. Please retry.',
+          cause: error,
+        });
+      }
+    }),
+
   deleteCard: authedProcedure
     .input(z.object({ cardId: z.string() }))
     .mutation(async ({ ctx, input }) => {
       const card = await ctx.db.flashcard.findFirst({
-        where: { id: input.cardId, artifact: { workspace: { ownerId: ctx.session.user.id } } },
+        where: { id: input.cardId, artifact: { workspace: workspaceAccessFilter(ctx.session.user.id) } },
       });
       if (!card) throw new TRPCError({ code: 'NOT_FOUND' });
       await ctx.db.flashcard.delete({ where: { id: input.cardId } });
@@ -132,14 +237,14 @@ export const flashcards = router({
     .input(z.object({ setId: z.string().uuid() }))
     .mutation(async ({ ctx, input }) => {
       const deleted = await ctx.db.artifact.deleteMany({
-        where: { id: input.setId, type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } },
+        where: { id: input.setId, type: ArtifactType.FLASHCARD_SET, workspace: workspaceAccessFilter(ctx.session.user.id) },
       });
       if (deleted.count === 0) throw new TRPCError({ code: 'NOT_FOUND' });
       return true;
     }),
 
   // Generate a flashcard set from a user prompt
-  generateFromPrompt: authedProcedure
+  generateFromPrompt: limitedProcedure
     .input(z.object({
       workspaceId: z.string(),
       prompt: z.string().min(1),
@@ -170,84 +275,106 @@ 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 });
 
-      await PusherService.emitTaskComplete(input.workspaceId, 'flash_card_info', { status: 'generating', numCards: input.numCards, difficulty: input.difficulty });
-
-      const artifact = await ctx.db.artifact.create({
-        data: {
-          workspaceId: input.workspaceId,
-          type: ArtifactType.FLASHCARD_SET,
-          title: input.title || `Flashcards - ${new Date().toLocaleString()}`,
-          createdById: ctx.session.user.id,
-          flashcards: {
-            create: flashcardCurrent?.flashcards.map((card) => ({
-              front: card.front,
-              back: card.back,
-            })),
+        const artifact = await ctx.db.artifact.create({
+          data: {
+            workspaceId: input.workspaceId,
+            type: ArtifactType.FLASHCARD_SET,
+            title: input.title || `Flashcards - ${new Date().toLocaleString()}`,
+            createdById: ctx.session.user.id,
+            generating: true,
+            generatingMetadata: { quantity: input.numCards, difficulty: input.difficulty.toLowerCase() },
+            flashcards: {
+              create: flashcardCurrent?.flashcards.map((card) => ({
+                front: card.front,
+                back: card.back,
+              })),
+            },
           },
-        },
-      });
-      
-      const currentCards = flashcardCurrent?.flashcards.length || 0;
-      const newCards = input.numCards - currentCards;
+        });
 
+        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);
 
-      let createdCards = 0;
-      try {
-        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}`;
-          const back = card.definition || card.back || card.answer || card.solution || `Answer ${i + 1}`;
-          await ctx.db.flashcard.create({
-            data: {
-              artifactId: artifact.id,
-              front,
-              back,
-              order: i,
-              tags: input.tags ?? ['ai-generated', input.difficulty],
-            },
-          });
-          createdCards++;
-        }
-      } catch {
-        // Fallback to text parsing if JSON fails
-        const lines = content.split('\n').filter(line => line.trim());
-        for (let i = 0; i < Math.min(lines.length, input.numCards); i++) {
-          const line = lines[i];
-          if (line.includes(' - ')) {
-            const [front, back] = line.split(' - ');
+        // Generate
+        const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, ctx.session.user.id, input.numCards, input.difficulty, input.prompt);
+
+        let createdCards = 0;
+        try {
+          const parsed = typeof content === 'string' ? JSON.parse(content) : content;
+          const flashcardData = Array.isArray(parsed) ? parsed : (parsed.flashcards || []);
+
+          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}`;
+            const back = card.definition || card.back || card.answer || card.solution || `Answer ${i + 1}`;
             await ctx.db.flashcard.create({
               data: {
                 artifactId: artifact.id,
-                front: front.trim(),
-                back: back.trim(),
+                front,
+                back,
                 order: i,
                 tags: input.tags ?? ['ai-generated', input.difficulty],
               },
             });
             createdCards++;
           }
+        } catch (error) {
+          console.error("Failed to parse flashcard JSON or create cards:", error);
+          // Fallback to text parsing if JSON fails
+          const lines = content.split('\n').filter(line => line.trim());
+          for (let i = 0; i < Math.min(lines.length, input.numCards); i++) {
+            const line = lines[i];
+            if (line.includes(' - ')) {
+              const [front, back] = line.split(' - ');
+              await ctx.db.flashcard.create({
+                data: {
+                  artifactId: artifact.id,
+                  front: front.trim(),
+                  back: back.trim(),
+                  order: i,
+                  tags: input.tags ?? ['ai-generated', input.difficulty],
+                },
+              });
+              createdCards++;
+            }
+          }
         }
-      }
 
-      // Pusher complete
-      await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
+        // Pusher complete
+        await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
+
+        // Set generating to false on the artifact
+        await ctx.db.artifact.update({ where: { id: artifact.id }, data: { generating: false } });
+
+        await notifyArtifactReady(ctx.db, {
+          userId: ctx.session.user.id,
+          workspaceId: input.workspaceId,
+          artifactId: artifact.id,
+          artifactType: ArtifactType.FLASHCARD_SET,
+          title: artifact.title,
+        }).catch(() => {});
 
-      return { artifact, createdCards };
+        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;
-    }
+      } catch (error) {
+        if (flashcardCurrent?.id) {
+          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');
+        await notifyArtifactFailed(ctx.db, {
+          userId: ctx.session.user.id,
+          workspaceId: input.workspaceId,
+          artifactType: ArtifactType.FLASHCARD_SET,
+          message:
+            error instanceof Error
+              ? error.message
+              : 'Flashcard generation failed.',
+        }).catch(() => {});
+        throw error;
+      }
     }),
 
   // Record study attempt