@goscribe/server 1.1.1 → 1.1.3

package/dist/services/flashcard-progress.service.d.ts

@@ -94,7 +94,7 @@ export declare class FlashcardProgressService {
     /**
      * Get flashcards due for review, non-studied flashcards, and flashcards with low mastery
      */
-    getDueFlashcards(userId: string, workspaceId: string): Promise<({
+    getDueFlashcards(userId: string, workspaceId: string): Promise<(({
         artifact: {
             id: string;
             createdAt: Date;
@@ -119,6 +119,30 @@ export declare class FlashcardProgressService {
         front: string;
         back: string;
         tags: string[];
+    }) | {
+        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[];
     })[]>;
     /**
      * Get user statistics for a flashcard set

package/dist/services/flashcard-progress.service.js

@@ -226,12 +226,23 @@ export class FlashcardProgressService {
     async getDueFlashcards(userId, workspaceId) {
         const now = new Date();
         const LOW_MASTERY_THRESHOLD = 50; // Consider mastery < 50 as low
-        // Get all flashcards in the workspace
+        // Get the latest artifact in the workspace
+        const latestArtifact = await this.db.artifact.findFirst({
+            where: {
+                workspaceId,
+                type: 'FLASHCARD_SET',
+            },
+            orderBy: {
+                updatedAt: 'desc',
+            },
+        });
+        if (!latestArtifact) {
+            return [];
+        }
+        // Get all flashcards from the latest artifact
         const allFlashcards = await this.db.flashcard.findMany({
             where: {
-                artifact: {
-                    workspaceId,
-                },
+                artifactId: latestArtifact.id,
             },
             include: {
                 artifact: true,
@@ -242,6 +253,7 @@ export class FlashcardProgressService {
                 },
             },
         });
+        console.log('allFlashcards', allFlashcards.length);
         const TAKE_NUMBER = (allFlashcards.length > 10) ? 10 : allFlashcards.length;
         // Get progress records for flashcards that are due or have low mastery
         const progressRecords = await this.db.flashcardProgress.findMany({
@@ -265,9 +277,7 @@ export class FlashcardProgressService {
                     }
                 ],
                 flashcard: {
-                    artifact: {
-                        workspaceId,
-                    },
+                    artifactId: latestArtifact.id,
                 },
             },
             include: {
@@ -279,6 +289,38 @@ export class FlashcardProgressService {
             },
             take: TAKE_NUMBER,
         });
+        console.log('TAKE_NUMBER', TAKE_NUMBER);
+        console.log('TAKE_NUMBER - progressRecords.length', TAKE_NUMBER - progressRecords.length);
+        console.log('progressRecords', progressRecords.map((progress) => progress.flashcard.id));
+        // Get flashcard IDs that already have progress records
+        const flashcardIdsWithProgress = new Set(progressRecords.map((progress) => progress.flashcard.id));
+        // Find flashcards without progress records (non-studied) to pad the results
+        const nonStudiedFlashcards = allFlashcards
+            .filter((flashcard) => !flashcardIdsWithProgress.has(flashcard.id))
+            .slice(0, TAKE_NUMBER - progressRecords.length);
+        // Create progress-like structures for non-studied flashcards
+        const progressRecordsPadding = nonStudiedFlashcards.map((flashcard) => {
+            const { progress, ...flashcardWithoutProgress } = flashcard;
+            return {
+                id: `temp-${flashcard.id}`,
+                userId,
+                flashcardId: flashcard.id,
+                timesStudied: 0,
+                timesCorrect: 0,
+                timesIncorrect: 0,
+                timesIncorrectConsecutive: 0,
+                easeFactor: 2.5,
+                interval: 0,
+                repetitions: 0,
+                masteryLevel: 0,
+                lastStudiedAt: null,
+                nextReviewAt: null,
+                flashcard: flashcardWithoutProgress,
+            };
+        });
+        console.log('progressRecordsPadding', progressRecordsPadding.length);
+        console.log('progressRecords', progressRecords.length);
+        const selectedCards = [...progressRecords, ...progressRecordsPadding];
         // Build result array: include progress records and non-studied flashcards
         const results = [];
         // Add flashcards with progress (due or low mastery)
@@ -286,30 +328,27 @@ export class FlashcardProgressService {
             results.push(progress);
         }
         // Sort by priority: due first (by nextReviewAt), then low mastery, then non-studied
-        results.sort((a, b) => {
-            // Due flashcards first (nextReviewAt <= now)
-            const aIsDue = a.nextReviewAt && a.nextReviewAt <= now;
-            const bIsDue = b.nextReviewAt && b.nextReviewAt <= now;
-            if (aIsDue && !bIsDue)
-                return -1;
-            if (!aIsDue && bIsDue)
-                return 1;
-            // Among due flashcards, sort by nextReviewAt
-            if (aIsDue && bIsDue && a.nextReviewAt && b.nextReviewAt) {
-                return a.nextReviewAt.getTime() - b.nextReviewAt.getTime();
-            }
-            // Then low mastery (lower mastery first)
-            if (a.masteryLevel !== b.masteryLevel) {
-                return a.masteryLevel - b.masteryLevel;
-            }
-            // Finally, non-studied (timesStudied === 0)
-            if (a.timesStudied === 0 && b.timesStudied !== 0)
-                return -1;
-            if (a.timesStudied !== 0 && b.timesStudied === 0)
-                return 1;
-            return 0;
-        });
-        return results.map((progress) => progress.flashcard);
+        // @todo: make an actual algorithm. research
+        // results.sort((a, b) => {
+        //   // Due flashcards first (nextReviewAt <= now)
+        //   const aIsDue = a.nextReviewAt && a.nextReviewAt <= now;
+        //   const bIsDue = b.nextReviewAt && b.nextReviewAt <= now;
+        //   // if (aIsDue && !bIsDue) return -1;
+        //   // if (!aIsDue && bIsDue) return 1;
+        //   // Among due flashcards, sort by nextReviewAt
+        //   if (aIsDue && bIsDue && a.nextReviewAt && b.nextReviewAt) {
+        //     return a.nextReviewAt.getTime() - b.nextReviewAt.getTime();
+        //   }
+        //   // Then low mastery (lower mastery first)
+        //   if (a.masteryLevel !== b.masteryLevel) {
+        //     return a.masteryLevel - b.masteryLevel;
+        //   }
+        //   // Finally, non-studied (timesStudied === 0)
+        //   if (a.timesStudied === 0 && b.timesStudied !== 0) return -1;
+        //   if (a.timesStudied !== 0 && b.timesStudied === 0) return 1;
+        //   return 0;
+        // });
+        return selectedCards.map((progress) => progress.flashcard);
     }
     /**
      * Get user statistics for a flashcard set

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goscribe/server",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,7 +22,7 @@
   "dependencies": {
     "@auth/express": "^0.11.0",
     "@auth/prisma-adapter": "^2.10.0",
-    "@goscribe/server": "^1.0.8",
+    "@goscribe/server": "^1.1.2",
     "@prisma/client": "^6.14.0",
     "@supabase/supabase-js": "^2.76.1",
     "@trpc/server": "^11.5.0",

package/prisma/schema.prisma

@@ -63,11 +63,21 @@ model User {
   // Invitations
   sentInvitations WorkspaceInvitation[] @relation("UserInvitations")
 
+  notifications Notification[]
   chats         Chat[]
   createdAt     DateTime  @default(now())
-  updatedAt     DateTime  @updatedAt
+  updatedAt     DateTime  @updatedAt  
 }
 
+model Notification {
+  id String @id @default(cuid())
+  userId String
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+  content String
+  read Boolean @default(false)
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
 model Session {
   id String @id @default(cuid())
   userId String
@@ -130,6 +140,8 @@ model Workspace {
 
   analysisProgress Json?
 
+  needsAnalysis Boolean @default(false)
+
   // Raw uploads attached to this workspace
   uploads     FileAsset[]
 
@@ -191,6 +203,7 @@ model FileAsset {
   objectKey String?
   url       String?  // optional if serving via signed GET per-view
   checksum  String?  // optional server-side integrity
+  aiTranscription Json? @default("{}")
 
   meta      Json?    // arbitrary metadata
 

package/src/lib/ai-session.ts

@@ -26,6 +26,19 @@ export interface AISession {
 
 const IMITATE_WAIT_TIME_MS = MOCK_MODE ?  1000 * 10 : 0;
 
+export interface ProcessFileResult {
+  status: 'success' | 'error';
+  textContent: string | null;
+  imageDescriptions: Array<{
+    page: number;
+    description: string;
+    hasVisualContent: boolean;
+  }>;
+  comprehensiveDescription: string | null;
+  pageCount: number;
+  error?: string;
+}
+
 export class AISessionService {
   private sessions = new Map<string, AISession>();
 
@@ -115,67 +128,105 @@ export class AISessionService {
     });
   }
 
-  // Upload file to AI session
-  async uploadFile(sessionId: string, user: string, file: File, fileType: 'image' | 'pdf'): Promise<void> {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
-    }
-
+  // Process file (PDF/image) and return comprehensive text descriptions
+  async processFile(
+    sessionId: string,
+    user: string,
+    fileUrl: string,
+    fileType: 'image' | 'pdf',
+    maxPages?: number
+  ): Promise<ProcessFileResult> {
     await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
-    // Mock mode - simulate successful file upload
+    
+    // Mock mode - return fake processing result
     if (MOCK_MODE) {
-      console.log(`🎭 MOCK MODE: Uploading ${fileType} file "${file.name}" to session ${sessionId}`);
-      session.files.push(file.name);
-      session.updatedAt = new Date();
-      this.sessions.set(sessionId, session);
-      return;
+      logger.info(`🎭 MOCK MODE: Processing ${fileType} file from URL for session ${sessionId}`);
+      const mockPageCount = fileType === 'pdf' ? 15 : 1;
+      return {
+        status: 'success',
+        textContent: `Mock extracted text content from ${fileType} file. This would contain the full text extracted from the document.`,
+        imageDescriptions: Array.from({ length: mockPageCount }, (_, i) => ({
+          page: i + 1,
+          description: `Page ${i + 1} contains educational content with diagrams and text.`,
+          hasVisualContent: true,
+        })),
+        comprehensiveDescription: `DOCUMENT SUMMARY (${mockPageCount} ${mockPageCount === 1 ? 'page' : 'pages'})\n\nTEXT CONTENT:\nMock extracted text content...\n\nVISUAL CONTENT DESCRIPTIONS:\nPage-by-page descriptions of visual elements.`,
+        pageCount: mockPageCount,
+      };
     }
 
-    const command = fileType === 'image' ? 'append_image' : 'append_pdflike';
-    
     const formData = new FormData();
-    formData.append('command', command);
-    formData.append('file', file);
-    formData.append('session', sessionId);
-    formData.append('user', user);
-    try {
-      const response = await fetch(AI_SERVICE_URL, {
-        method: 'POST',
-        body: formData,
-      });
+    formData.append('command', 'process_file');
+    formData.append('fileUrl', fileUrl);
+    formData.append('fileType', fileType);
+    if (maxPages) {
+      formData.append('maxPages', maxPages.toString());
+    }
 
-      if (!response.ok) {
-        throw new Error(`AI service error: ${response.status} ${response.statusText}`);
-      }
+    console.log('formData', formData);
 
-      const result = await response.json();
-      console.log(`📋 Upload result:`, result);
-      if (!result.message) {
-        throw new Error(`AI service error: No response message`);
-      }
+    // Retry logic for file processing
+    const maxRetries = 3;
+    let lastError: Error | null = null;
 
-      // Update session
-      session.files.push(file.name);
-      session.updatedAt = new Date();
-      this.sessions.set(sessionId, session);
-    } catch (error) {
-      throw new TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        message: `Failed to upload file: ${error instanceof Error ? error.message : 'Unknown error'}`,
-      });
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        logger.info(`📄 Processing ${fileType} file attempt ${attempt}/${maxRetries} for session ${sessionId}`);
+        
+        // Set timeout for large files (5 minutes)
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 300000); // 5 min timeout
+
+        const response = await fetch(AI_SERVICE_URL, {
+          method: 'POST',
+          body: formData,
+          // signal: controller.signal,
+        });
+
+        clearTimeout(timeoutId);
+
+        if (!response.ok) {
+          const errorText = await response.text();
+          logger.error(`❌ File processing error response:`, errorText);
+          throw new Error(`AI service error: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+
+        const result = await response.json();
+        logger.info(`📋 File processing result: status=${result.status}, pageCount=${result.pageCount}`);
+
+        if (result.status === 'error') {
+          throw new Error(result.error || 'File processing failed');
+        }
+
+        return result as ProcessFileResult;
+        
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error('Unknown error');
+        logger.error(`❌ File processing attempt ${attempt} failed:`, lastError.message);
+        
+        if (attempt < maxRetries) {
+          const delay = Math.pow(2, attempt) * 1000; // Exponential backoff: 2s, 4s, 8s
+          logger.info(`⏳ Retrying file processing in ${delay}ms...`);
+          await new Promise(resolve => setTimeout(resolve, delay));
+        }
+      }
     }
+
+    logger.error(`💥 All ${maxRetries} file processing attempts failed. Last error:`, lastError?.message);
+    return {
+      status: 'error',
+      textContent: null,
+      imageDescriptions: [],
+      comprehensiveDescription: null,
+      pageCount: 0,
+      error: `Failed to process file after ${maxRetries} attempts: ${lastError?.message || 'Unknown error'}`,
+    };
   }
 
 
 
   // Generate study guide
   async generateStudyGuide(sessionId: string, user: string): Promise<string> {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
-    }
-
     await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
     // Mock mode - return fake study guide
     if (MOCK_MODE) {
@@ -227,11 +278,6 @@ This mock study guide demonstrates the structure and format that would be genera
 
   // Generate flashcard questions
   async generateFlashcardQuestions(sessionId: string, user: string, numQuestions: number, difficulty: 'easy' | 'medium' | 'hard'): Promise<string> {
-    // const session = this.sessions.get(sessionId);
-    // if (!session) {
-    //   throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
-    // }
-
     await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
     // Mock mode - return fake flashcard questions
     if (MOCK_MODE) {
@@ -503,113 +549,6 @@ This mock study guide demonstrates the structure and format that would be genera
   }
   
 
-  // Analyse PDF
-  async analysePDF(sessionId: string, user: string): Promise<string> {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
-    }
-
-    await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
-    // Mock mode - return fake PDF analysis
-    if (MOCK_MODE) {
-      console.log(`🎭 MOCK MODE: Analysing PDF for session ${sessionId}`);
-      return `Mock PDF Analysis Results:
-
-Document Type: Educational Material
-Pages: 15
-Language: English
-Key Topics Identified:
-- Introduction to Machine Learning
-- Data Preprocessing Techniques
-- Model Training and Validation
-- Performance Metrics
-
-Summary: This mock PDF analysis shows the structure and content that would be extracted from an uploaded PDF document. The analysis includes document metadata, key topics, and a summary of the content.
-
-Note: This is a mock response generated when DONT_TEST_INFERENCE=true`;
-    }
-
-    const formData = new FormData();
-    formData.append('command', 'analyse_pdf');
-    formData.append('session', sessionId);
-    formData.append('user', user);
-    try {
-      const response = await fetch(AI_SERVICE_URL, {
-        method: 'POST',
-        body: formData,
-      });
-
-      if (!response.ok) {
-        throw new Error(`AI service error: ${response.status} ${response.statusText}`);
-      }
-
-      const result = await response.json();
-      return result.message || 'PDF analysis completed';
-    } catch (error) {
-      throw new TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        message: `Failed to analyse PDF: ${error instanceof Error ? error.message : 'Unknown error'}`,
-      });
-    }
-  }
-
-  // Analyse Image
-  async analyseImage(sessionId: string, user: string): Promise<string> {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
-    }
-
-    await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
-    // Mock mode - return fake image analysis
-    if (MOCK_MODE) {
-      console.log(`🎭 MOCK MODE: Analysing image for session ${sessionId}`);
-      return `Mock Image Analysis Results:
-
-Image Type: Educational Diagram
-Format: PNG
-Dimensions: 1920x1080
-Content Description:
-- Contains a flowchart or diagram
-- Shows a process or system architecture
-- Includes text labels and annotations
-- Educational or instructional content
-
-Key Elements Identified:
-- Process flow arrows
-- Decision points
-- Input/output elements
-- Descriptive text
-
-Summary: This mock image analysis demonstrates the type of content extraction that would be performed on uploaded images. The analysis identifies visual elements, text content, and overall structure.
-
-Note: This is a mock response generated when DONT_TEST_INFERENCE=true`;
-    }
-
-    const formData = new FormData();
-    formData.append('command', 'analyse_img');
-    formData.append('session', sessionId);
-    formData.append('user', user);
-    try {
-      const response = await fetch(AI_SERVICE_URL, {
-        method: 'POST',
-        body: formData,
-      });
-
-      if (!response.ok) {
-        throw new Error(`AI service error: ${response.status} ${response.statusText}`);
-      }
-
-      const result = await response.json();
-      return result.message || 'Image analysis completed';
-    } catch (error) {
-      throw new TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        message: `Failed to analyse image: ${error instanceof Error ? error.message : 'Unknown error'}`,
-      });
-    }
-  }
 
   async generatePodcastImage(sessionId: string, user: string, summary: string): Promise<string> {
 

package/src/routers/flashcards.ts

@@ -177,22 +177,6 @@ export const flashcards = router({
 
       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,
-      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}
-      `
       const artifact = await ctx.db.artifact.create({
         data: {
           workspaceId: input.workspaceId,

package/src/routers/members.ts

@@ -230,7 +230,16 @@ export const members = router({
         invitedByName: invitation.workspace.owner.name || invitation.workspace.owner.email,
       };
     }),
-
+  getInvitations: authedProcedure
+    .input(z.object({
+      workspaceId: z.string(),
+    }))
+    .query(async ({ ctx, input }) => {
+      const invitations = await ctx.db.workspaceInvitation.findMany({
+        where: { workspaceId: input.workspaceId },
+      });
+      return invitations;
+    }),
   /**
    * Accept an invitation (public endpoint)
    */
@@ -277,8 +286,10 @@ export const members = router({
         });
       }
 
+      const user = await ctx.db.user.findFirst({ where: { id: ctx.session.user.id } });
+      if (!user || !user.email) throw new TRPCError({ code: 'NOT_FOUND' });
       // Check if the email matches the user's email
-      if (ctx.session.user.email !== invitation.email) {
+      if (user.email !== invitation.email) {
         throw new TRPCError({ 
           code: 'BAD_REQUEST', 
           message: 'This invitation was sent to a different email address' 

package/src/routers/podcast.ts

@@ -877,7 +877,6 @@ export const podcast = router({
         updatedAt: segment.updatedAt,
       };
     }),
-
   // Get available voices for TTS
   getAvailableVoices: authedProcedure
     .query(async () => {

package/src/routers/worksheets.ts

@@ -281,6 +281,7 @@ export const worksheets = router({
           userAnswer: input.answer,
           completedAt: input.completed ? new Date() : null,
           attempts: { increment: 1 },
+          correct: input.correct,
         },
       });
 
@@ -490,7 +491,7 @@ export const worksheets = router({
       
       // Parse question meta to get mark_scheme
       const questionMeta = question.meta ? (typeof question.meta === 'object' ? question.meta : JSON.parse(question.meta as any)) : {} as any;
-      const markScheme = questionMeta.mark_scheme;
+      const markScheme = questionMeta.markScheme;
 
       let isCorrect = false;
       let userMarkScheme = null;
@@ -517,7 +518,7 @@ export const worksheets = router({
         }
       } else {
         // Simple string comparison if no mark scheme
-        isCorrect = question.answer === input.answer;
+        throw new TRPCError({ code: 'BAD_REQUEST', message: 'No mark scheme found for question' });
       }