@goscribe/server 1.0.11 → 1.1.1

package/dist/routers/_app.js

@@ -6,6 +6,7 @@ import { worksheets } from './worksheets.js';
 import { studyguide } from './studyguide.js';
 import { podcast } from './podcast.js';
 import { chat } from './chat.js';
+import { members } from './members.js';
 export const appRouter = router({
     auth,
     workspace,
@@ -14,4 +15,8 @@ export const appRouter = router({
     studyguide,
     podcast,
     chat,
+    // Public member endpoints (for invitation acceptance)
+    member: router({
+        acceptInvite: members.acceptInvite,
+    }),
 });

package/dist/routers/auth.d.ts

@@ -7,7 +7,17 @@ export declare const auth: import("@trpc/server").TRPCBuiltRouter<{
         cookies: Record<string, string | undefined>;
     };
     meta: object;
-    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    errorShape: {
+        data: {
+            zodError: string | null;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
     transformer: true;
 }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
     signup: import("@trpc/server").TRPCMutationProcedure<{

package/dist/routers/chat.d.ts

@@ -7,7 +7,17 @@ export declare const chat: import("@trpc/server").TRPCBuiltRouter<{
         cookies: Record<string, string | undefined>;
     };
     meta: object;
-    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    errorShape: {
+        data: {
+            zodError: string | null;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
     transformer: true;
 }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
     getChannels: import("@trpc/server").TRPCQueryProcedure<{

package/dist/routers/flashcards.d.ts

@@ -7,7 +7,17 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
         cookies: Record<string, string | undefined>;
     };
     meta: object;
-    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    errorShape: {
+        data: {
+            zodError: string | null;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
     transformer: true;
 }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
     listSets: import("@trpc/server").TRPCQueryProcedure<{
@@ -33,8 +43,11 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
             workspaceId: string;
             type: import("@prisma/client").$Enums.ArtifactType;
             isArchived: boolean;
+            generating: boolean;
+            generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
             difficulty: import("@prisma/client").$Enums.Difficulty | null;
             estimatedTime: string | null;
+            imageObjectKey: string | null;
             createdById: string | null;
         })[];
         meta: object;
@@ -43,15 +56,40 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
         input: {
             workspaceId: string;
         };
-        output: {
+        output: ({
+            progress: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                flashcardId: string;
+                timesStudied: number;
+                timesCorrect: number;
+                timesIncorrect: number;
+                timesIncorrectConsecutive: number;
+                easeFactor: number;
+                interval: number;
+                repetitions: number;
+                masteryLevel: number;
+                lastStudiedAt: Date | null;
+                nextReviewAt: Date | null;
+            }[];
+        } & {
             id: string;
             createdAt: Date;
             artifactId: string;
+            order: number;
             front: string;
             back: string;
             tags: string[];
-            order: number;
-        }[];
+        })[];
+        meta: object;
+    }>;
+    isGenerating: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            workspaceId: string;
+        };
+        output: boolean | undefined;
         meta: object;
     }>;
     createCard: import("@trpc/server").TRPCMutationProcedure<{
@@ -66,10 +104,10 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
             id: string;
             createdAt: Date;
             artifactId: string;
+            order: number;
             front: string;
             back: string;
             tags: string[];
-            order: number;
         };
         meta: object;
     }>;
@@ -85,10 +123,10 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
             id: string;
             createdAt: Date;
             artifactId: string;
+            order: number;
             front: string;
             back: string;
             tags: string[];
-            order: number;
         };
         meta: object;
     }>;
@@ -125,12 +163,173 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
                 workspaceId: string;
                 type: import("@prisma/client").$Enums.ArtifactType;
                 isArchived: boolean;
+                generating: boolean;
+                generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
                 difficulty: import("@prisma/client").$Enums.Difficulty | null;
                 estimatedTime: string | null;
+                imageObjectKey: string | null;
                 createdById: string | null;
             };
             createdCards: number;
         };
         meta: object;
     }>;
+    recordStudyAttempt: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            flashcardId: string;
+            isCorrect: boolean;
+            confidence?: "easy" | "medium" | "hard" | undefined;
+            timeSpentMs?: number | undefined;
+        };
+        output: {
+            flashcard: {
+                id: string;
+                createdAt: Date;
+                artifactId: string;
+                order: number;
+                front: string;
+                back: string;
+                tags: string[];
+            };
+        } & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            flashcardId: string;
+            timesStudied: number;
+            timesCorrect: number;
+            timesIncorrect: number;
+            timesIncorrectConsecutive: number;
+            easeFactor: number;
+            interval: number;
+            repetitions: number;
+            masteryLevel: number;
+            lastStudiedAt: Date | null;
+            nextReviewAt: Date | null;
+        };
+        meta: object;
+    }>;
+    getSetProgress: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            artifactId: string;
+        };
+        output: {
+            flashcardId: any;
+            front: any;
+            back: any;
+            progress: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                userId: string;
+                flashcardId: string;
+                timesStudied: number;
+                timesCorrect: number;
+                timesIncorrect: number;
+                timesIncorrectConsecutive: number;
+                easeFactor: number;
+                interval: number;
+                repetitions: number;
+                masteryLevel: number;
+                lastStudiedAt: Date | null;
+                nextReviewAt: Date | null;
+            } | null;
+        }[];
+        meta: object;
+    }>;
+    getDueFlashcards: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            workspaceId: string;
+        };
+        output: ({
+            artifact: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                title: string;
+                description: string | null;
+                workspaceId: string;
+                type: import("@prisma/client").$Enums.ArtifactType;
+                isArchived: boolean;
+                generating: boolean;
+                generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
+                difficulty: import("@prisma/client").$Enums.Difficulty | null;
+                estimatedTime: string | null;
+                imageObjectKey: string | null;
+                createdById: string | null;
+            };
+        } & {
+            id: string;
+            createdAt: Date;
+            artifactId: string;
+            order: number;
+            front: string;
+            back: string;
+            tags: string[];
+        })[];
+        meta: object;
+    }>;
+    getSetStatistics: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            artifactId: string;
+        };
+        output: {
+            totalCards: number;
+            studiedCards: number;
+            unstudiedCards: number;
+            masteredCards: number;
+            dueForReview: number;
+            averageMastery: number;
+            successRate: number;
+            totalAttempts: number;
+            totalCorrect: number;
+        };
+        meta: object;
+    }>;
+    resetProgress: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            flashcardId: string;
+        };
+        output: import("@prisma/client").Prisma.BatchPayload;
+        meta: object;
+    }>;
+    recordStudySession: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            attempts: {
+                flashcardId: string;
+                isCorrect: boolean;
+                confidence?: "easy" | "medium" | "hard" | undefined;
+                timeSpentMs?: number | undefined;
+            }[];
+        };
+        output: ({
+            flashcard: {
+                id: string;
+                createdAt: Date;
+                artifactId: string;
+                order: number;
+                front: string;
+                back: string;
+                tags: string[];
+            };
+        } & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            flashcardId: string;
+            timesStudied: number;
+            timesCorrect: number;
+            timesIncorrect: number;
+            timesIncorrectConsecutive: number;
+            easeFactor: number;
+            interval: number;
+            repetitions: number;
+            masteryLevel: number;
+            lastStudiedAt: Date | null;
+            nextReviewAt: Date | null;
+        })[];
+        meta: object;
+    }>;
 }>>;

package/dist/routers/flashcards.js

@@ -3,6 +3,7 @@ import { TRPCError } from '@trpc/server';
 import { router, authedProcedure } from '../trpc.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',
@@ -37,7 +38,15 @@ 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' },
         });
@@ -45,6 +54,14 @@ export const flashcards = router({
             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,25 +154,30 @@ 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: {
                 updatedAt: 'desc',
             },
         });
-        const formattedPreviousCards = flashcardCurrent?.flashcards.map((card) => ({
-            front: card.front,
-            back: card.back,
-        }));
-        const partialPrompt = `
+        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,
+                back: card.back,
+            }));
+            const partialPrompt = `
       This is the users previous flashcards, avoid repeating any existing cards.
       Please generate ${input.numCards} new cards,
       Of a ${input.difficulty} difficulty,
@@ -165,63 +187,36 @@ 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);
-        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,
-                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,
-                    })),
-                },
-            },
-        });
-        // Parse and create cards
-        let createdCards = 0;
-        try {
-            const flashcardData = JSON.parse(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],
+            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,
+                        })),
                     },
-                });
-                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(' - ');
+                },
+            });
+            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 = 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: front.trim(),
-                            back: back.trim(),
+                            front,
+                            back,
                             order: i,
                             tags: input.tags ?? ['ai-generated', input.difficulty],
                         },
@@ -229,11 +224,94 @@ export const flashcards = router({
                     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(' - ');
+                        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);
+            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;
         }
-        // Pusher complete
-        await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
-        // Cleanup AI session (best-effort)
-        aiSessionService.deleteSession(session.id);
-        return { artifact, createdCards };
+    }),
+    // 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,
+        });
     }),
 });