@goscribe/server 1.2.0 → 1.3.1

package/dist/routers/flashcards.d.ts

@@ -1,11 +1,5 @@
 export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
-    ctx: {
-        db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
-        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: Record<string, string | undefined>;
-    };
+    ctx: import("../context.js").Context;
     meta: object;
     errorShape: {
         data: {
@@ -38,17 +32,18 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
             id: string;
             createdAt: Date;
             updatedAt: Date;
-            title: string;
-            description: string | null;
             workspaceId: string;
             type: import("@prisma/client").$Enums.ArtifactType;
+            title: string;
             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;
+            description: string | null;
+            generating: boolean;
+            generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
+            worksheetConfig: import("@prisma/client/runtime/library").JsonValue | null;
+            imageObjectKey: string | null;
         })[];
         meta: object;
     }>;
@@ -82,6 +77,7 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
             front: string;
             back: string;
             tags: string[];
+            acceptedAnswers: string[];
         })[];
         meta: object;
     }>;
@@ -97,6 +93,7 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
             workspaceId: string;
             front: string;
             back: string;
+            acceptedAnswers?: string[] | undefined;
             tags?: string[] | undefined;
             order?: number | undefined;
         };
@@ -108,6 +105,7 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
             front: string;
             back: string;
             tags: string[];
+            acceptedAnswers: string[];
         };
         meta: object;
     }>;
@@ -116,6 +114,7 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
             cardId: string;
             front?: string | undefined;
             back?: string | undefined;
+            acceptedAnswers?: string[] | undefined;
             tags?: string[] | undefined;
             order?: number | undefined;
         };
@@ -127,6 +126,20 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
             front: string;
             back: string;
             tags: string[];
+            acceptedAnswers: string[];
+        };
+        meta: object;
+    }>;
+    gradeTypedAnswer: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            flashcardId: string;
+            userAnswer: string;
+        };
+        output: {
+            isCorrect: boolean;
+            confidence: number;
+            reason: string;
+            matchedAnswer: string | null;
         };
         meta: object;
     }>;
@@ -158,17 +171,18 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
                 id: string;
                 createdAt: Date;
                 updatedAt: Date;
-                title: string;
-                description: string | null;
                 workspaceId: string;
                 type: import("@prisma/client").$Enums.ArtifactType;
+                title: string;
                 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;
+                description: string | null;
+                generating: boolean;
+                generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
+                worksheetConfig: import("@prisma/client/runtime/library").JsonValue | null;
+                imageObjectKey: string | null;
             };
             createdCards: number;
         };
@@ -181,33 +195,7 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
             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;
-        };
+        output: any;
         meta: object;
     }>;
     getSetProgress: import("@trpc/server").TRPCQueryProcedure<{
@@ -247,17 +235,18 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
                 id: string;
                 createdAt: Date;
                 updatedAt: Date;
-                title: string;
-                description: string | null;
                 workspaceId: string;
                 type: import("@prisma/client").$Enums.ArtifactType;
+                title: string;
                 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;
+                description: string | null;
+                generating: boolean;
+                generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
+                worksheetConfig: import("@prisma/client/runtime/library").JsonValue | null;
+                imageObjectKey: string | null;
             };
         } & {
             id: string;
@@ -267,22 +256,24 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
             front: string;
             back: string;
             tags: string[];
+            acceptedAnswers: string[];
         }) | {
             artifact: {
                 id: string;
                 createdAt: Date;
                 updatedAt: Date;
-                title: string;
-                description: string | null;
                 workspaceId: string;
                 type: import("@prisma/client").$Enums.ArtifactType;
+                title: string;
                 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;
+                description: string | null;
+                generating: boolean;
+                generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
+                worksheetConfig: import("@prisma/client/runtime/library").JsonValue | null;
+                imageObjectKey: string | null;
             };
             id: string;
             createdAt: Date;
@@ -291,6 +282,7 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
             front: string;
             back: string;
             tags: string[];
+            acceptedAnswers: string[];
         })[];
         meta: object;
     }>;
@@ -327,33 +319,7 @@ export declare const flashcards: import("@trpc/server").TRPCBuiltRouter<{
                 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;
-        })[];
+        output: any[];
         meta: object;
     }>;
 }>>;

package/dist/routers/flashcards.js

@@ -1,17 +1,43 @@
 import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
-import { router, authedProcedure } from '../trpc.js';
+import { router, authedProcedure, limitedProcedure } from '../trpc.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',
-};
+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) {
+    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 const flashcards = router({
     listSets: authedProcedure
         .input(z.object({ workspaceId: z.string() }))
@@ -36,7 +62,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: {
@@ -48,7 +74,7 @@ export const flashcards = router({
                     }
                 },
             },
-            orderBy: { updatedAt: 'desc' },
+            orderBy: { createdAt: 'desc' },
         });
         if (!set)
             throw new TRPCError({ code: 'NOT_FOUND' });
@@ -58,23 +84,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: {
+            where: {
+                type: ArtifactType.FLASHCARD_SET, workspace: {
                     id: input.workspaceId,
-                } },
+                }
+            },
             include: {
                 flashcards: true,
             },
@@ -87,6 +117,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,
             },
@@ -97,12 +128,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' });
@@ -111,16 +143,81 @@ 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' });
@@ -131,14 +228,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),
@@ -168,10 +265,6 @@ 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 });
             const artifact = await ctx.db.artifact.create({
                 data: {
@@ -179,6 +272,8 @@ export const flashcards = router({
                     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,
@@ -190,10 +285,11 @@ export const flashcards = router({
             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);
+            const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, ctx.session.user.id, input.numCards, input.difficulty, input.prompt);
             let createdCards = 0;
             try {
-                const flashcardData = content;
+                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}`;
@@ -210,7 +306,8 @@ export const flashcards = router({
                     createdCards++;
                 }
             }
-            catch {
+            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++) {
@@ -232,11 +329,30 @@ export const flashcards = router({
             }
             // 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 };
         }
         catch (error) {
-            await ctx.db.artifact.update({ where: { id: flashcardCurrent?.id }, data: { generating: false } });
+            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;
         }
     }),

package/dist/routers/members.d.ts

@@ -10,13 +10,7 @@
  * - Get current user's role
  */
 export declare const members: import("@trpc/server").TRPCBuiltRouter<{
-    ctx: {
-        db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
-        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: Record<string, string | undefined>;
-    };
+    ctx: import("../context.js").Context;
     meta: object;
     errorShape: {
         data: {
@@ -109,6 +103,7 @@ export declare const members: import("@trpc/server").TRPCBuiltRouter<{
             token: string;
         };
         output: {
+            message?: string | undefined;
             workspaceId: string;
             workspaceTitle: string;
             role: string;
@@ -178,4 +173,38 @@ export declare const members: import("@trpc/server").TRPCBuiltRouter<{
         };
         meta: object;
     }>;
+    /**
+     * Resend a pending invitation (owner only)
+     */
+    resendInvitation: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            invitationId: string;
+        };
+        output: {
+            invitationId: string;
+            message: string;
+        };
+        meta: object;
+    }>;
+    /**
+     * DEBUG ONLY: Get all invitations for a workspace
+     */
+    getAllInvitationsDebug: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            workspaceId: string;
+        };
+        output: {
+            id: string;
+            email: string;
+            createdAt: Date;
+            updatedAt: Date;
+            workspaceId: string;
+            role: string;
+            token: string;
+            invitedById: string;
+            acceptedAt: Date | null;
+            expiresAt: Date;
+        }[];
+        meta: object;
+    }>;
 }>>;