@goscribe/server 1.3.4 → 1.6.0

package/src/services/content/flashcard.service.ts

@@ -0,0 +1,417 @@
+import type { PrismaClient } from '@prisma/client';
+import { TRPCError } from '@trpc/server';
+import { z } from 'zod';
+import { BaseService } from '../base.service.js';
+import { ArtifactType } from '../../lib/constants.js';
+import { workspaceAccessWhere } from '../../repositories/workspace.repository.js';
+import { ai } from '../../lib/ai/index.js';
+import { workspaceKbService } from '../workspace/workspace-kb.service.js';
+import PusherService from '../../lib/pusher.js';
+import { notifyArtifactFailed, notifyArtifactReady } from '../notifications/notification.service.js';
+import { invalidateUserBillingCache } from '../billing/usage.service.js';
+
+export 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 class FlashcardService extends BaseService {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  private async findPrimarySet(userId: string, workspaceId: string) {
+    const sets = await this.db.artifact.findMany({
+      where: {
+        workspaceId,
+        type: ArtifactType.FLASHCARD_SET,
+        workspace: workspaceAccessWhere(userId),
+      },
+      include: {
+        flashcards: { orderBy: { order: 'asc' } },
+        _count: { select: { flashcards: true } },
+      },
+      orderBy: { createdAt: 'asc' },
+    });
+    if (sets.length === 0) return null;
+
+    const withCards = sets.filter((set) => set._count.flashcards > 0);
+    const candidates = withCards.length > 0 ? withCards : sets;
+    return candidates.reduce((best, current) =>
+      current._count.flashcards > best._count.flashcards ? current : best,
+    );
+  }
+
+  /** Returns the primary set, creating one only when flashcard content is first added. */
+  async ensurePrimarySet(userId: string, workspaceId: string) {
+    const existing = await this.findPrimarySet(userId, workspaceId);
+    if (existing) return existing;
+
+    const workspace = await this.db.workspace.findFirst({
+      where: { id: workspaceId, ...workspaceAccessWhere(userId) },
+      select: { id: true, title: true },
+    });
+    if (!workspace) {
+      throw new TRPCError({ code: 'NOT_FOUND', message: 'Workspace not found' });
+    }
+
+    return this.db.artifact.create({
+      data: {
+        workspaceId,
+        type: ArtifactType.FLASHCARD_SET,
+        title: 'Flashcards',
+        createdById: userId,
+      },
+      include: {
+        flashcards: { orderBy: { order: 'asc' } },
+        _count: { select: { flashcards: true } },
+      },
+    });
+  }
+
+  async listSets(userId: string, workspaceId: string) {
+    const workspace = await this.db.workspace.findFirst({
+      where: { id: workspaceId, ownerId: userId },
+    });
+    if (!workspace) throw new TRPCError({ code: 'NOT_FOUND' });
+    return this.db.artifact.findMany({
+      where: { workspaceId, type: ArtifactType.FLASHCARD_SET },
+      include: {
+        versions: { orderBy: { version: 'desc' }, take: 1 },
+      },
+      orderBy: { updatedAt: 'desc' },
+    });
+  }
+
+  async listCards(userId: string, workspaceId: string) {
+    const set = await this.findPrimarySet(userId, workspaceId);
+    if (!set) return [];
+    return this.db.flashcard.findMany({
+      where: { artifactId: set.id },
+      include: {
+        progress: { where: { userId } },
+      },
+      orderBy: { order: 'asc' },
+    });
+  }
+
+  async isGenerating(userId: string, workspaceId: string) {
+    const set = await this.findPrimarySet(userId, workspaceId);
+    return set?.generating ?? false;
+  }
+
+  async createCard(
+    userId: string,
+    input: {
+      workspaceId: string;
+      front: string;
+      back: string;
+      acceptedAnswers?: string[];
+      tags?: string[];
+      order?: number;
+    },
+  ) {
+    const set = await this.ensurePrimarySet(userId, input.workspaceId);
+    const nextOrder =
+      input.order ??
+      (set.flashcards.reduce((max, card) => Math.max(max, card.order), -1) + 1);
+    const card = await this.db.flashcard.create({
+      data: {
+        artifactId: set.id,
+        front: input.front,
+        back: input.back,
+        acceptedAnswers: normalizeAcceptedAnswers(input.acceptedAnswers),
+        tags: input.tags ?? [],
+        order: nextOrder,
+      },
+    });
+    invalidateUserBillingCache(userId);
+    return card;
+  }
+
+  async updateCard(
+    userId: string,
+    input: {
+      cardId: string;
+      front?: string;
+      back?: string;
+      acceptedAnswers?: string[];
+      tags?: string[];
+      order?: number;
+    },
+  ) {
+    const card = await this.db.flashcard.findFirst({
+      where: {
+        id: input.cardId,
+        artifact: {
+          type: ArtifactType.FLASHCARD_SET,
+          workspace: workspaceAccessWhere(userId),
+        },
+      },
+    });
+    if (!card) throw new TRPCError({ code: 'NOT_FOUND' });
+    return this.db.flashcard.update({
+      where: { id: input.cardId },
+      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,
+      },
+    });
+  }
+
+  async gradeTypedAnswer(
+    userId: string,
+    input: { flashcardId: string; userAnswer: string },
+  ) {
+    const flashcard = await this.db.flashcard.findFirst({
+      where: {
+        id: input.flashcardId,
+        artifact: {
+          type: ArtifactType.FLASHCARD_SET,
+          workspace: workspaceAccessWhere(userId),
+        },
+      },
+      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 ai.llm.complete([{ 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,
+      });
+    }
+  }
+
+  async deleteCard(userId: string, cardId: string) {
+    const card = await this.db.flashcard.findFirst({
+      where: {
+        id: cardId,
+        artifact: { workspace: workspaceAccessWhere(userId) },
+      },
+    });
+    if (!card) throw new TRPCError({ code: 'NOT_FOUND' });
+    await this.db.flashcard.delete({ where: { id: cardId } });
+    return true;
+  }
+
+  async deleteSet(userId: string, setId: string) {
+    const deleted = await this.db.artifact.deleteMany({
+      where: {
+        id: setId,
+        type: ArtifactType.FLASHCARD_SET,
+        workspace: workspaceAccessWhere(userId),
+      },
+    });
+    if (deleted.count === 0) throw new TRPCError({ code: 'NOT_FOUND' });
+    return true;
+  }
+
+  async generateFromPrompt(
+    userId: string,
+    input: {
+      workspaceId: string;
+      prompt: string;
+      numCards: number;
+      difficulty: 'easy' | 'medium' | 'hard';
+      title?: string;
+      tags?: string[];
+    },
+  ) {
+    const workspace = await this.db.workspace.findFirst({
+      where: { id: input.workspaceId, ownerId: userId },
+    });
+    if (!workspace) throw new TRPCError({ code: 'NOT_FOUND' });
+
+    const primarySet = await this.ensurePrimarySet(userId, input.workspaceId);
+    const orderOffset = primarySet.flashcards.reduce(
+      (max, card) => Math.max(max, card.order),
+      -1,
+    );
+
+    try {
+      await PusherService.emitTaskComplete(input.workspaceId, 'flash_card_info', {
+        status: 'generating',
+        numCards: input.numCards,
+        difficulty: input.difficulty,
+      });
+
+      await this.db.artifact.update({
+        where: { id: primarySet.id },
+        data: {
+          generating: true,
+          generatingMetadata: {
+            quantity: input.numCards,
+            difficulty: input.difficulty.toLowerCase(),
+          },
+          ...(input.title ? { title: input.title } : {}),
+        },
+      });
+
+      const ragContext = await workspaceKbService.retrieveContext(
+        input.workspaceId,
+        input.prompt ?? 'flashcard key concepts facts definitions',
+        8,
+      );
+
+      const content = await ai.backend.generateFlashcardQuestions(
+        input.workspaceId,
+        userId,
+        input.numCards,
+        input.difficulty,
+        input.prompt,
+        { ragContext },
+      );
+
+      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 this.db.flashcard.create({
+            data: {
+              artifactId: primarySet.id,
+              front,
+              back,
+              order: orderOffset + 1 + i,
+              tags: input.tags ?? ['ai-generated', input.difficulty],
+            },
+          });
+          createdCards++;
+        }
+      } catch (error) {
+        console.error('Failed to parse flashcard JSON or create cards:', error);
+        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 this.db.flashcard.create({
+              data: {
+                artifactId: primarySet.id,
+                front: front.trim(),
+                back: back.trim(),
+                order: orderOffset + 1 + i,
+                tags: input.tags ?? ['ai-generated', input.difficulty],
+              },
+            });
+            createdCards++;
+          }
+        }
+      }
+
+      const artifact = await this.db.artifact.update({
+        where: { id: primarySet.id },
+        data: { generating: false },
+        include: { flashcards: true },
+      });
+
+      await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
+
+      await notifyArtifactReady(this.db, {
+        userId,
+        workspaceId: input.workspaceId,
+        artifactId: artifact.id,
+        artifactType: ArtifactType.FLASHCARD_SET,
+        title: artifact.title,
+      }).catch(() => {});
+
+      invalidateUserBillingCache(userId);
+      return { artifact, createdCards };
+    } catch (error) {
+      await this.db.artifact
+        .update({
+          where: { id: primarySet.id },
+          data: { generating: false },
+        })
+        .catch(() => {});
+      await PusherService.emitError(
+        input.workspaceId,
+        `Failed to generate flashcards: ${error}`,
+        'flash_card_generation',
+      );
+      await notifyArtifactFailed(this.db, {
+        userId,
+        workspaceId: input.workspaceId,
+        artifactType: ArtifactType.FLASHCARD_SET,
+        message: error instanceof Error ? error.message : 'Flashcard generation failed.',
+      }).catch(() => {});
+      throw error;
+    }
+  }
+}