@goscribe/server 1.0.7 → 1.0.9

package/dist/routers/flashcards.d.ts

@@ -4,7 +4,7 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
         session: any;
         req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
         res: import("express").Response<any, Record<string, any>>;
-        cookies: any;
+        cookies: Record<string, string | undefined>;
     };
     meta: object;
     errorShape: import("@trpc/server").TRPCDefaultErrorShape;
@@ -14,64 +14,49 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
         input: {
             workspaceId: string;
         };
-        output: {
+        output: ({
+            versions: {
+                id: string;
+                createdAt: Date;
+                createdById: string | null;
+                artifactId: string;
+                content: string;
+                data: import("@prisma/client/runtime/library").JsonValue | null;
+                version: number;
+            }[];
+        } & {
             id: string;
             createdAt: Date;
             updatedAt: Date;
             title: string;
+            description: string | null;
             workspaceId: string;
             type: import("@prisma/client").$Enums.ArtifactType;
             isArchived: boolean;
+            difficulty: import("@prisma/client").$Enums.Difficulty | null;
+            estimatedTime: string | null;
             createdById: string | null;
-        }[];
+        })[];
         meta: object;
     }>;
-    createSet: import("@trpc/server").TRPCMutationProcedure<{
+    listCards: import("@trpc/server").TRPCQueryProcedure<{
         input: {
             workspaceId: string;
-            title: string;
         };
         output: {
             id: string;
             createdAt: Date;
-            updatedAt: Date;
-            title: string;
-            workspaceId: string;
-            type: import("@prisma/client").$Enums.ArtifactType;
-            isArchived: boolean;
-            createdById: string | null;
-        };
-        meta: object;
-    }>;
-    getSet: import("@trpc/server").TRPCQueryProcedure<{
-        input: {
-            setId: string;
-        };
-        output: {
-            flashcards: {
-                id: string;
-                createdAt: Date;
-                artifactId: string;
-                front: string;
-                back: string;
-                tags: string[];
-                order: number;
-            }[];
-        } & {
-            id: string;
-            createdAt: Date;
-            updatedAt: Date;
-            title: string;
-            workspaceId: string;
-            type: import("@prisma/client").$Enums.ArtifactType;
-            isArchived: boolean;
-            createdById: string | null;
-        };
+            artifactId: string;
+            front: string;
+            back: string;
+            tags: string[];
+            order: number;
+        }[];
         meta: object;
     }>;
     createCard: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            setId: string;
+            workspaceId: string;
             front: string;
             back: string;
             tags?: string[] | undefined;
@@ -121,4 +106,31 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
         output: boolean;
         meta: object;
     }>;
+    generateFromPrompt: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workspaceId: string;
+            prompt: string;
+            numCards?: number | undefined;
+            difficulty?: "easy" | "medium" | "hard" | undefined;
+            title?: string | undefined;
+            tags?: string[] | undefined;
+        };
+        output: {
+            artifact: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                title: string;
+                description: string | null;
+                workspaceId: string;
+                type: import("@prisma/client").$Enums.ArtifactType;
+                isArchived: boolean;
+                difficulty: import("@prisma/client").$Enums.Difficulty | null;
+                estimatedTime: string | null;
+                createdById: string | null;
+            };
+            createdCards: number;
+        };
+        meta: object;
+    }>;
 }>>;

package/dist/routers/flashcards.js

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
 import { router, authedProcedure } from '../trpc.js';
+import { aiSessionService } from '../lib/ai-session.js';
+import PusherService from '../lib/pusher.js';
 // Prisma enum values mapped manually to avoid type import issues in ESM
 const ArtifactType = {
     STUDY_GUIDE: 'STUDY_GUIDE',
@@ -11,7 +13,7 @@ const ArtifactType = {
 };
 export const flashcards = router({
     listSets: authedProcedure
-        .input(z.object({ workspaceId: z.string().uuid() }))
+        .input(z.object({ workspaceId: z.string() }))
         .query(async ({ ctx, input }) => {
         const workspace = await ctx.db.workspace.findFirst({
             where: { id: input.workspaceId, ownerId: ctx.session.user.id },
@@ -20,44 +22,32 @@ export const flashcards = router({
             throw new TRPCError({ code: 'NOT_FOUND' });
         return ctx.db.artifact.findMany({
             where: { workspaceId: input.workspaceId, type: ArtifactType.FLASHCARD_SET },
-            orderBy: { updatedAt: 'desc' },
-        });
-    }),
-    createSet: authedProcedure
-        .input(z.object({ workspaceId: z.string().uuid(), title: z.string().min(1).max(120) }))
-        .mutation(async ({ ctx, input }) => {
-        const workspace = await ctx.db.workspace.findFirst({
-            where: { id: input.workspaceId, ownerId: ctx.session.user.id },
-        });
-        if (!workspace)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        return ctx.db.artifact.create({
-            data: {
-                workspaceId: input.workspaceId,
-                type: ArtifactType.FLASHCARD_SET,
-                title: input.title,
-                createdById: ctx.session.user.id,
+            include: {
+                versions: {
+                    orderBy: { version: 'desc' },
+                    take: 1, // Get only the latest version
+                },
             },
+            orderBy: { updatedAt: 'desc' },
         });
     }),
-    getSet: authedProcedure
-        .input(z.object({ setId: z.string().uuid() }))
+    listCards: authedProcedure
+        .input(z.object({ workspaceId: z.string() }))
         .query(async ({ ctx, input }) => {
         const set = await ctx.db.artifact.findFirst({
-            where: {
-                id: input.setId,
-                type: ArtifactType.FLASHCARD_SET,
-                workspace: { ownerId: ctx.session.user.id },
+            where: { workspaceId: input.workspaceId, type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } },
+            include: {
+                flashcards: true,
             },
-            include: { flashcards: true },
+            orderBy: { updatedAt: 'desc' },
         });
         if (!set)
             throw new TRPCError({ code: 'NOT_FOUND' });
-        return set;
+        return set.flashcards;
     }),
     createCard: authedProcedure
         .input(z.object({
-        setId: z.string().uuid(),
+        workspaceId: z.string(),
         front: z.string().min(1),
         back: z.string().min(1),
         tags: z.array(z.string()).optional(),
@@ -65,13 +55,19 @@ export const flashcards = router({
     }))
         .mutation(async ({ ctx, input }) => {
         const set = await ctx.db.artifact.findFirst({
-            where: { id: input.setId, type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } },
+            where: { type: ArtifactType.FLASHCARD_SET, workspace: {
+                    id: input.workspaceId,
+                } },
+            include: {
+                flashcards: true,
+            },
+            orderBy: { updatedAt: 'desc' },
         });
         if (!set)
             throw new TRPCError({ code: 'NOT_FOUND' });
         return ctx.db.flashcard.create({
             data: {
-                artifactId: input.setId,
+                artifactId: set.id,
                 front: input.front,
                 back: input.back,
                 tags: input.tags ?? [],
@@ -81,7 +77,7 @@ export const flashcards = router({
     }),
     updateCard: authedProcedure
         .input(z.object({
-        cardId: z.string().uuid(),
+        cardId: z.string(),
         front: z.string().optional(),
         back: z.string().optional(),
         tags: z.array(z.string()).optional(),
@@ -104,7 +100,7 @@ export const flashcards = router({
         });
     }),
     deleteCard: authedProcedure
-        .input(z.object({ cardId: z.string().uuid() }))
+        .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 } } },
@@ -124,4 +120,120 @@ export const flashcards = router({
             throw new TRPCError({ code: 'NOT_FOUND' });
         return true;
     }),
+    // Generate a flashcard set from a user prompt
+    generateFromPrompt: authedProcedure
+        .input(z.object({
+        workspaceId: z.string(),
+        prompt: z.string().min(1),
+        numCards: z.number().int().min(1).max(50).default(10),
+        difficulty: z.enum(['easy', 'medium', 'hard']).default('medium'),
+        title: z.string().optional(),
+        tags: z.array(z.string()).optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        // Verify workspace ownership
+        const workspace = await ctx.db.workspace.findFirst({
+            where: { id: input.workspaceId, ownerId: ctx.session.user.id },
+        });
+        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: {
+                flashcards: true,
+            },
+            orderBy: {
+                updatedAt: 'desc',
+            },
+        });
+        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,
+      Of a ${input.tags?.join(', ')} tag,
+      Of a ${input.title} title.
+      ${formattedPreviousCards?.map((card) => `Front: ${card.front}\nBack: ${card.back}`).join('\n')}
+
+      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],
+                    },
+                });
+                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);
+        // Cleanup AI session (best-effort)
+        aiSessionService.deleteSession(session.id);
+        return { artifact, createdCards };
+    }),
 });