@goscribe/server 1.3.4 → 1.6.0

package/dist/services/content/flashcard.service.js

@@ -0,0 +1,339 @@
+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) {
+    if (!answers || answers.length === 0)
+        return [];
+    const seen = new Set();
+    const normalized = [];
+    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) {
+    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) {
+        super(db);
+    }
+    async findPrimarySet(userId, workspaceId) {
+        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, workspaceId) {
+        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, workspaceId) {
+        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, workspaceId) {
+        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, workspaceId) {
+        const set = await this.findPrimarySet(userId, workspaceId);
+        return set?.generating ?? false;
+    }
+    async createCard(userId, input) {
+        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, input) {
+        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, input) {
+        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, cardId) {
+        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, setId) {
+        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, input) {
+        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;
+        }
+    }
+}

package/dist/services/content/media-analysis.service.d.ts

@@ -0,0 +1,23 @@
+import type { PrismaClient } from '@prisma/client';
+import { BaseService } from '../base.service.js';
+export interface UploadAndAnalyzeInput {
+    workspaceId: string;
+    files: Array<{
+        id: string;
+    }>;
+    generateStudyGuide: boolean;
+    generateFlashcards: boolean;
+    generateWorksheet: boolean;
+}
+export declare class MediaAnalysisService extends BaseService {
+    constructor(db: PrismaClient);
+    private updateAnalysisProgress;
+    uploadAndAnalyzeMedia(input: UploadAndAnalyzeInput, userId: string): Promise<{
+        filename: string;
+        artifacts: {
+            studyGuide: any | null;
+            flashcards: any | null;
+            worksheet: any | null;
+        };
+    }>;
+}