@goscribe/server 1.1.1 → 1.1.3

package/src/routers/workspace.ts

@@ -6,6 +6,7 @@ import { ArtifactType } from '@prisma/client';
 import { aiSessionService } from '../lib/ai-session.js';
 import PusherService from '../lib/pusher.js';
 import { members } from './members.js';
+import { logger } from '../lib/logger.js';
 import type { PrismaClient } from '@prisma/client';
 
 // Helper function to update and emit analysis progress
@@ -25,17 +26,17 @@ async function updateAnalysisProgress(
 function calculateRelevance(query: string, ...texts: (string | null | undefined)[]): number {
   const queryLower = query.toLowerCase();
   let score = 0;
-  
+
   for (const text of texts) {
     if (!text) continue;
-    
+
     const textLower = text.toLowerCase();
-    
+
     // Exact match gets highest score
     if (textLower.includes(queryLower)) {
       score += 10;
     }
-    
+
     // Word boundary matches get good score
     const words = queryLower.split(/\s+/);
     for (const word of words) {
@@ -43,7 +44,7 @@ function calculateRelevance(query: string, ...texts: (string | null | undefined)
         score += 5;
       }
     }
-    
+
     // Partial matches get lower score
     const queryChars = queryLower.split('');
     let consecutiveMatches = 0;
@@ -56,7 +57,7 @@ function calculateRelevance(query: string, ...texts: (string | null | undefined)
     }
     score += consecutiveMatches * 0.1;
   }
-  
+
   return score;
 }
 
@@ -64,8 +65,8 @@ export const workspace = router({
   // List current user's workspaces
   list: authedProcedure
     .input(z.object({
-        parentId: z.string().optional(),
-     }))
+      parentId: z.string().optional(),
+    }))
     .query(async ({ ctx, input }) => {
       const workspaces = await ctx.db.workspace.findMany({
         where: {
@@ -84,14 +85,14 @@ export const workspace = router({
 
       return { workspaces, folders };
     }),
-    
+
   create: authedProcedure
     .input(z.object({
-        name: z.string().min(1).max(100),
-        description: z.string().max(500).optional(),
-        parentId: z.string().optional(),
-     }))
-    .mutation(async ({ ctx, input}) => {
+      name: z.string().min(1).max(100),
+      description: z.string().max(500).optional(),
+      parentId: z.string().optional(),
+    }))
+    .mutation(async ({ ctx, input }) => {
       const ws = await ctx.db.workspace.create({
         data: {
           title: input.name,
@@ -118,10 +119,10 @@ export const workspace = router({
     }),
   createFolder: authedProcedure
     .input(z.object({
-        name: z.string().min(1).max(100),
-        color: z.string().optional(),
-        parentId: z.string().optional(),
-     }))
+      name: z.string().min(1).max(100),
+      color: z.string().optional(),
+      parentId: z.string().optional(),
+    }))
     .mutation(async ({ ctx, input }) => {
       const folder = await ctx.db.folder.create({
         data: {
@@ -135,26 +136,26 @@ export const workspace = router({
     }),
   updateFolder: authedProcedure
     .input(z.object({
-        id: z.string(),
-        name: z.string().min(1).max(100).optional(),
-        color: z.string().optional(),
-     }))
+      id: z.string(),
+      name: z.string().min(1).max(100).optional(),
+      color: z.string().optional(),
+    }))
     .mutation(async ({ ctx, input }) => {
       const folder = await ctx.db.folder.update({ where: { id: input.id }, data: { name: input.name, color: input.color ?? '#9D00FF' } });
       return folder;
     }),
   deleteFolder: authedProcedure
     .input(z.object({
-        id: z.string(),
-     }))
+      id: z.string(),
+    }))
     .mutation(async ({ ctx, input }) => {
       const folder = await ctx.db.folder.delete({ where: { id: input.id } });
       return folder;
     }),
   get: authedProcedure
     .input(z.object({
-        id: z.string(),
-     }))
+      id: z.string(),
+    }))
     .query(async ({ ctx, input }) => {
       const ws = await ctx.db.workspace.findFirst({
         where: { id: input.id, ownerId: ctx.session.user.id },
@@ -170,13 +171,13 @@ export const workspace = router({
   getStats: authedProcedure
     .query(async ({ ctx }) => {
       const workspaces = await ctx.db.workspace.findMany({
-        where: {OR: [{ ownerId: ctx.session.user.id }, { sharedWith: { some: { id: ctx.session.user.id } } }]},
+        where: { OR: [{ ownerId: ctx.session.user.id }, { sharedWith: { some: { id: ctx.session.user.id } } }] },
       });
       const folders = await ctx.db.folder.findMany({
-        where: {OR: [{ ownerId: ctx.session.user.id } ]},
+        where: { OR: [{ ownerId: ctx.session.user.id }] },
       });
       const lastUpdated = await ctx.db.workspace.findFirst({
-        where: {OR: [{ ownerId: ctx.session.user.id }, { sharedWith: { some: { id: ctx.session.user.id } } }]},
+        where: { OR: [{ ownerId: ctx.session.user.id }, { sharedWith: { some: { id: ctx.session.user.id } } }] },
         orderBy: { updatedAt: 'desc' },
       });
 
@@ -195,12 +196,12 @@ export const workspace = router({
     }),
   update: authedProcedure
     .input(z.object({
-        id: z.string(),
-        name: z.string().min(1).max(100).optional(),
-        description: z.string().max(500).optional(),
-        color: z.string().optional(),
-        icon: z.string().optional(),
-     }))
+      id: z.string(),
+      name: z.string().min(1).max(100).optional(),
+      description: z.string().max(500).optional(),
+      color: z.string().optional(),
+      icon: z.string().optional(),
+    }))
     .mutation(async ({ ctx, input }) => {
       const existed = await ctx.db.workspace.findFirst({
         where: { id: input.id, ownerId: ctx.session.user.id },
@@ -215,12 +216,12 @@ export const workspace = router({
           icon: input.icon ?? existed.icon,
         },
       });
-      return updated; 
-    }), 
-    delete: authedProcedure
+      return updated;
+    }),
+  delete: authedProcedure
     .input(z.object({
-        id: z.string(),
-     }))
+      id: z.string(),
+    }))
     .mutation(async ({ ctx, input }) => {
       const deleted = await ctx.db.workspace.deleteMany({
         where: { id: input.id, ownerId: ctx.session.user.id },
@@ -228,15 +229,15 @@ export const workspace = router({
       if (deleted.count === 0) throw new TRPCError({ code: 'NOT_FOUND' });
       return true;
     }),
-    getFolderInformation: authedProcedure
+  getFolderInformation: authedProcedure
     .input(z.object({
-        id: z.string(),
-     }))
+      id: z.string(),
+    }))
     .query(async ({ ctx, input }) => {
       const folder = await ctx.db.folder.findFirst({ where: { id: input.id, ownerId: ctx.session.user.id } });
       // find all of its parents
       if (!folder) throw new TRPCError({ code: 'NOT_FOUND' });
-      
+
       const parents = [];
       let current = folder;
 
@@ -246,20 +247,36 @@ export const workspace = router({
         parents.push(parent);
         current = parent;
       }
-      
+
       return { folder, parents };
     }),
-    uploadFiles: authedProcedure
+
+  getSharedWith: authedProcedure
     .input(z.object({
-        id: z.string(),
-        files: z.array(
-          z.object({
-            filename: z.string().min(1).max(255),
-            contentType: z.string().min(1).max(100),
-            size: z.number().min(1), // size in bytes
-          })
-        ),
-     }))
+      id: z.string(),
+    }))
+    .query(async ({ ctx, input }) => {
+
+      const user = await ctx.db.user.findFirst({ where: { id: ctx.session.user.id } });
+      if (!user || !user.email) throw new TRPCError({ code: 'NOT_FOUND' });
+      const sharedWith = await ctx.db.workspace.findMany({ where: { members: { some: { userId: ctx.session.user.id } } } });
+      const invitations = await ctx.db.workspaceInvitation.findMany({ where: { email: user.email, acceptedAt: null }, include: {
+        workspace: true,
+      } });
+
+      return { shared: sharedWith, invitations };
+    }),
+  uploadFiles: authedProcedure
+    .input(z.object({
+      id: z.string(),
+      files: z.array(
+        z.object({
+          filename: z.string().min(1).max(255),
+          contentType: z.string().min(1).max(100),
+          size: z.number().min(1), // size in bytes
+        })
+      ),
+    }))
     .mutation(async ({ ctx, input }) => {
       // ensure workspace belongs to user
       const ws = await ctx.db.workspace.findFirst({ where: { id: input.id, ownerId: ctx.session.user.id } });
@@ -274,7 +291,7 @@ export const workspace = router({
             name: file.filename,
             mimeType: file.contentType,
             size: file.size,
-            workspaceId: input.id,   
+            workspaceId: input.id,
           },
         });
 
@@ -285,9 +302,9 @@ export const workspace = router({
           .createSignedUploadUrl(objectKey); // 5 minutes
 
         if (signedUrlError) {
-          throw new TRPCError({ 
-            code: 'INTERNAL_SERVER_ERROR', 
-            message: `Failed to generate upload URL: ${signedUrlError.message}` 
+          throw new TRPCError({
+            code: 'INTERNAL_SERVER_ERROR',
+            message: `Failed to generate upload URL: ${signedUrlError.message}`
           });
         }
 
@@ -298,7 +315,7 @@ export const workspace = router({
             bucket: 'files',
             objectKey: objectKey,
           },
-        }); 
+        });
 
         results.push({
           fileId: record.id,
@@ -309,11 +326,11 @@ export const workspace = router({
       return results;
 
     }),
-    deleteFiles: authedProcedure
+  deleteFiles: authedProcedure
     .input(z.object({
-        fileId: z.array(z.string()),
-        id: z.string(),
-     }))
+      fileId: z.array(z.string()),
+      id: z.string(),
+    }))
     .mutation(async ({ ctx, input }) => {
       // ensure files are in the user's workspace
       const files = await ctx.db.fileAsset.findMany({
@@ -344,7 +361,7 @@ export const workspace = router({
       });
       return true;
     }),
-    getFileUploadUrl: authedProcedure
+  getFileUploadUrl: authedProcedure
     .input(z.object({
       workspaceId: z.string(),
       filename: z.string(),
@@ -353,7 +370,7 @@ export const workspace = router({
     }))
     .query(async ({ ctx, input }) => {
       const objectKey = `workspace_${ctx.session.user.id}/${input.workspaceId}-file_${input.filename}`;
-      await ctx.db.fileAsset.create({
+      const fileAsset = await ctx.db.fileAsset.create({
         data: {
           workspaceId: input.workspaceId,
           name: input.filename,
@@ -370,31 +387,28 @@ export const workspace = router({
       if (signedUrlError) {
         throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: `Failed to generate upload URL: ${signedUrlError.message}` });
       }
-      return signedUrlData.signedUrl;
+
+      await ctx.db.workspace.update({
+        where: { id: input.workspaceId },
+        data: { needsAnalysis: true },
+      });
+
+      return {
+        fileId: fileAsset.id,
+        uploadUrl: signedUrlData.signedUrl,
+      };
     }),
-    uploadAndAnalyzeMedia: authedProcedure
+  uploadAndAnalyzeMedia: authedProcedure
     .input(z.object({
       workspaceId: z.string(),
-      file: z.object({
-        filename: z.string(),
-        contentType: z.string(),
-        size: z.number(),
-        content: z.string(), // Base64 encoded file content
-      }),
+      files: z.array(z.object({
+        id: z.string(),
+      })),
       generateStudyGuide: z.boolean().default(true),
       generateFlashcards: z.boolean().default(true),
       generateWorksheet: z.boolean().default(true),
     }))
     .mutation(async ({ ctx, input }) => {
-      console.log('🚀 uploadAndAnalyzeMedia started', { 
-        workspaceId: input.workspaceId, 
-        filename: input.file.filename,
-        fileSize: input.file.size,
-        generateStudyGuide: input.generateStudyGuide,
-        generateFlashcards: input.generateFlashcards,
-        generateWorksheet: input.generateWorksheet
-      });
-
       // Verify workspace ownership
       const workspace = await ctx.db.workspace.findFirst({
         where: { id: input.workspaceId, ownerId: ctx.session.user.id }
@@ -404,138 +418,108 @@ export const workspace = router({
         throw new TRPCError({ code: 'NOT_FOUND' });
       }
 
-      const fileType = input.file.contentType.startsWith('image/') ? 'image' : 'pdf';
-      
-      await ctx.db.workspace.update({
-        where: { id: input.workspaceId },
-        data: { fileBeingAnalyzed: true },
+      // Check if analysis is already in progress
+      if (workspace.fileBeingAnalyzed) {
+        throw new TRPCError({
+          code: 'CONFLICT',
+          message: 'File analysis is already in progress for this workspace. Please wait for it to complete.'
+        });
+      }
+
+      // Fetch files from database
+      const files = await ctx.db.fileAsset.findMany({
+        where: {
+          id: { in: input.files.map(file => file.id) },
+          workspaceId: input.workspaceId,
+          userId: ctx.session.user.id,
+        },
       });
 
-      try {
-      
-      await updateAnalysisProgress(ctx.db, input.workspaceId, {
-        status: 'starting',
-        filename: input.file.filename,
-        fileType,
-        startedAt: new Date().toISOString(),
-        steps: {
-          fileUpload: {
-            order: 1,
-            status: 'pending',
-          },
-          fileAnalysis: {
-            order: 2,
-            status: 'pending',
-          },
-          studyGuide: {
-            order: 3,
-            status: input.generateStudyGuide ? 'pending' : 'skipped',
-          },
-          flashcards: {
-            order: 4,
-            status: input.generateFlashcards ? 'pending' : 'skipped',
-          },
+      if (files.length === 0) {
+        throw new TRPCError({
+          code: 'NOT_FOUND',
+          message: 'No files found with the provided IDs'
+        });
+      }
+
+      // Validate all files have bucket and objectKey
+      for (const file of files) {
+        if (!file.bucket || !file.objectKey) {
+          throw new TRPCError({
+            code: 'BAD_REQUEST',
+            message: `File ${file.id} does not have bucket or objectKey set`
+          });
         }
-      });
-      } catch (error) {
-        console.error('❌ Failed to update analysis progress:', error);
+      }
+
+      // Use the first file for progress tracking and artifact naming
+      const primaryFile = files[0];
+      const fileType = primaryFile.mimeType.startsWith('image/') ? 'image' : 'pdf';
+      try {
+        // Set analysis in progress flag
         await ctx.db.workspace.update({
           where: { id: input.workspaceId },
-          data: { fileBeingAnalyzed: false },
+          data: { fileBeingAnalyzed: true },
         });
-        await PusherService.emitError(input.workspaceId, `Failed to update analysis progress: ${error}`, 'file_analysis');
-        throw error;
-      }
 
-      const fileBuffer = Buffer.from(input.file.content, 'base64');
-
-      // // Check AI service health first
-      // console.log('🏥 Checking AI service health...');
-      // const isHealthy = await aiSessionService.checkHealth();
-      // if (!isHealthy) {
-      //   console.error('❌ AI service is not available');
-      //   await PusherService.emitError(input.workspaceId, 'AI service is currently unavailable');
-      //   throw new TRPCError({
-      //     code: 'SERVICE_UNAVAILABLE',
-      //     message: 'AI service is currently unavailable. Please try again later.',
-      //   });
-      // }
-      // console.log('✅ AI service is healthy');
-
-      const fileObj = new File([fileBuffer], input.file.filename, { type: input.file.contentType });
-
-      await updateAnalysisProgress(ctx.db, input.workspaceId, {
-        status: 'uploading',
-        filename: input.file.filename,
-        fileType,
-        startedAt: new Date().toISOString(),
-        steps: {
-          fileUpload: {
-            order: 1,
-            status: 'in_progress',
-          },
-          fileAnalysis: {
-            order: 2,
-            status: 'pending',
-          },
-          studyGuide: {
-            order: 3,
-            status: input.generateStudyGuide ? 'pending' : 'skipped',
-          },
-          flashcards: {
-            order: 4,
-            status: input.generateFlashcards ? 'pending' : 'skipped',
+        PusherService.emitAnalysisProgress(input.workspaceId, {
+          status: 'starting',
+          filename: primaryFile.name,
+          fileType,
+          startedAt: new Date().toISOString(),
+          steps: {
+            fileUpload: { order: 1, status: 'pending' },
           },
-        }
-      });
+        });
 
-      await aiSessionService.uploadFile(input.workspaceId, ctx.session.user.id, fileObj, fileType);
-
-      await updateAnalysisProgress(ctx.db, input.workspaceId, {
-        status: 'analyzing',
-        filename: input.file.filename,
-        fileType,
-        startedAt: new Date().toISOString(),
-        steps: {
-          fileUpload: {
-            order: 1,
-            status: 'completed',
-          },
-          fileAnalysis: {
-            order: 2,
-            status: 'in_progress',
-          },
-          studyGuide: {
-            order: 3,
-            status: input.generateStudyGuide ? 'pending' : 'skipped',
-          },
-          flashcards: {
-            order: 4,
-            status: input.generateFlashcards ? 'pending' : 'skipped',
-          },
+        try {
+          await updateAnalysisProgress(ctx.db, input.workspaceId, {
+            status: 'starting',
+            filename: primaryFile.name,
+            fileType,
+            startedAt: new Date().toISOString(),
+            steps: {
+              fileUpload: {
+                order: 1,
+                status: 'pending',
+              },
+              fileAnalysis: {
+                order: 2,
+                status: 'pending',
+              },
+              studyGuide: {
+                order: 3,
+                status: input.generateStudyGuide ? 'pending' : 'skipped',
+              },
+              flashcards: {
+                order: 4,
+                status: input.generateFlashcards ? 'pending' : 'skipped',
+              },
+            }
+          });
+        } catch (error) {
+          console.error('❌ Failed to update analysis progress:', error);
+          await ctx.db.workspace.update({
+            where: { id: input.workspaceId },
+            data: { fileBeingAnalyzed: false },
+          });
+          await PusherService.emitError(input.workspaceId, `Failed to update analysis progress: ${error}`, 'file_analysis');
+          throw error;
         }
-      });
 
-      try {
-        if (fileType === 'image') {
-          await aiSessionService.analyseImage(input.workspaceId, ctx.session.user.id);
-        } else {
-          await aiSessionService.analysePDF(input.workspaceId, ctx.session.user.id );
-        }
-        
         await updateAnalysisProgress(ctx.db, input.workspaceId, {
-          status: 'generating_artifacts',
-          filename: input.file.filename,
+          status: 'uploading',
+          filename: primaryFile.name,
           fileType,
           startedAt: new Date().toISOString(),
           steps: {
             fileUpload: {
               order: 1,
-              status: 'completed',
+              status: 'in_progress',
             },
             fileAnalysis: {
               order: 2,
-              status: 'completed',
+              status: 'pending',
             },
             studyGuide: {
               order: 3,
@@ -547,57 +531,67 @@ export const workspace = router({
             },
           }
         });
-      } catch (error) {
-        console.error('❌ Failed to analyze file:', error);
-        await updateAnalysisProgress(ctx.db, input.workspaceId, {
-          status: 'error',
-          filename: input.file.filename,
-          fileType,
-          error: `Failed to analyze ${fileType}: ${error}`,
-          startedAt: new Date().toISOString(),
-          steps: {
-            fileUpload: {
-              order: 1,
-              status: 'completed',
-            },
-            fileAnalysis: {
-              order: 2,
-              status: 'error',
-            },
-            studyGuide: {
-              order: 3,
-              status: 'skipped',
-            },
-            flashcards: {
-              order: 4,
-              status: 'skipped',
-            },
+
+        // Process all files using the new process_file endpoint
+        for (const file of files) {
+          // TypeScript: We already validated bucket and objectKey exist above
+          if (!file.bucket || !file.objectKey) {
+            continue; // Skip if somehow missing (shouldn't happen due to validation above)
           }
-        });
-        throw error;
-      }
 
-      const results: {
-        filename: string;
-        artifacts: {
-          studyGuide: any | null;
-          flashcards: any | null;
-          worksheet: any | null;
-        };
-      } = { 
-        filename: input.file.filename, 
-        artifacts: {
-          studyGuide: null,
-          flashcards: null,
-          worksheet: null,
-        } 
-      };
+          const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
+            .from(file.bucket)
+            .createSignedUrl(file.objectKey, 24 * 60 * 60); // 24 hours expiry
+
+          if (signedUrlError) {
+            await ctx.db.workspace.update({
+              where: { id: input.workspaceId },
+              data: { fileBeingAnalyzed: false },
+            });
+            throw new TRPCError({
+              code: 'INTERNAL_SERVER_ERROR',
+              message: `Failed to generate signed URL for file ${file.name}: ${signedUrlError.message}`
+            });
+          }
+
+          const fileUrl = signedUrlData.signedUrl;
+          const currentFileType = file.mimeType.startsWith('image/') ? 'image' : 'pdf';
+
+          // Use maxPages for large PDFs (>50 pages) to limit processing
+          const maxPages = currentFileType === 'pdf' && file.size && file.size > 50 ? 50 : undefined;
+
+          const processResult = await aiSessionService.processFile(
+            input.workspaceId,
+            ctx.session.user.id,
+            fileUrl,
+            currentFileType,
+            maxPages
+          );
+          
+          if (processResult.status === 'error') {
+            logger.error(`Failed to process file ${file.name}:`, processResult.error);
+            // Continue processing other files even if one fails
+            // Optionally, you could throw an error or mark this file as failed
+          } else {
+            logger.info(`Successfully processed file ${file.name}: ${processResult.pageCount} pages`);
+
+            // Store the comprehensive description in aiTranscription field
+            await ctx.db.fileAsset.update({
+              where: { id: file.id },
+              data: {
+                aiTranscription: {
+                  comprehensiveDescription: processResult.comprehensiveDescription,
+                  textContent: processResult.textContent,
+                  imageDescriptions: processResult.imageDescriptions,
+                },
+              }
+            });
+          }
+        }
 
-      // Generate artifacts
-      if (input.generateStudyGuide) {
         await updateAnalysisProgress(ctx.db, input.workspaceId, {
-          status: 'generating_study_guide',
-          filename: input.file.filename,
+          status: 'analyzing',
+          filename: primaryFile.name,
           fileType,
           startedAt: new Date().toISOString(),
           steps: {
@@ -607,11 +601,11 @@ export const workspace = router({
             },
             fileAnalysis: {
               order: 2,
-              status: 'completed',
+              status: 'in_progress',
             },
             studyGuide: {
               order: 3,
-              status: 'in_progress',
+              status: input.generateStudyGuide ? 'pending' : 'skipped',
             },
             flashcards: {
               order: 4,
@@ -619,41 +613,242 @@ export const workspace = router({
             },
           }
         });
-        
-        const content = await aiSessionService.generateStudyGuide(input.workspaceId, ctx.session.user.id);
 
-        let artifact = await ctx.db.artifact.findFirst({
-          where: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE },
-        });
-        if (!artifact) {
-          artifact = await ctx.db.artifact.create({
+        try {
+          // Analyze all files - use PDF analysis if any file is a PDF, otherwise use image analysis
+          // const hasPDF = files.some(f => !f.mimeType.startsWith('image/'));
+          // if (hasPDF) {
+          //   await aiSessionService.analysePDF(input.workspaceId, ctx.session.user.id, file.id);
+          // } else {
+          //   // If all files are images, analyze them
+          //   for (const file of files) {
+          //     await aiSessionService.analyseImage(input.workspaceId, ctx.session.user.id, file.id);
+          //   }
+          // }
+
+          await updateAnalysisProgress(ctx.db, input.workspaceId, {
+            status: 'generating_artifacts',
+            filename: primaryFile.name,
+            fileType,
+            startedAt: new Date().toISOString(),
+            steps: {
+              fileUpload: {
+                order: 1,
+                status: 'completed',
+              },
+              fileAnalysis: {
+                order: 2,
+                status: 'completed',
+              },
+              studyGuide: {
+                order: 3,
+                status: input.generateStudyGuide ? 'pending' : 'skipped',
+              },
+              flashcards: {
+                order: 4,
+                status: input.generateFlashcards ? 'pending' : 'skipped',
+              },
+            }
+          });
+        } catch (error) {
+          console.error('❌ Failed to analyze files:', error);
+          await updateAnalysisProgress(ctx.db, input.workspaceId, {
+            status: 'error',
+            filename: primaryFile.name,
+            fileType,
+            error: `Failed to analyze ${fileType}: ${error}`,
+            startedAt: new Date().toISOString(),
+            steps: {
+              fileUpload: {
+                order: 1,
+                status: 'completed',
+              },
+              fileAnalysis: {
+                order: 2,
+                status: 'error',
+              },
+              studyGuide: {
+                order: 3,
+                status: 'skipped',
+              },
+              flashcards: {
+                order: 4,
+                status: 'skipped',
+              },
+            }
+          });
+          await ctx.db.workspace.update({
+            where: { id: input.workspaceId },
+            data: { fileBeingAnalyzed: false },
+          });
+          throw error;
+        }
+
+        const results: {
+          filename: string;
+          artifacts: {
+            studyGuide: any | null;
+            flashcards: any | null;
+            worksheet: any | null;
+          };
+        } = {
+          filename: primaryFile.name,
+          artifacts: {
+            studyGuide: null,
+            flashcards: null,
+            worksheet: null,
+          }
+        };
+
+        // Generate artifacts
+        if (input.generateStudyGuide) {
+          await updateAnalysisProgress(ctx.db, input.workspaceId, {
+            status: 'generating_study_guide',
+            filename: primaryFile.name,
+            fileType,
+            startedAt: new Date().toISOString(),
+            steps: {
+              fileUpload: {
+                order: 1,
+                status: 'completed',
+              },
+              fileAnalysis: {
+                order: 2,
+                status: 'completed',
+              },
+              studyGuide: {
+                order: 3,
+                status: 'in_progress',
+              },
+              flashcards: {
+                order: 4,
+                status: input.generateFlashcards ? 'pending' : 'skipped',
+              },
+            }
+          });
+
+          const content = await aiSessionService.generateStudyGuide(input.workspaceId, ctx.session.user.id);
+
+          let artifact = await ctx.db.artifact.findFirst({
+            where: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE },
+          });
+          if (!artifact) {
+            const fileNames = files.map(f => f.name).join(', ');
+            artifact = await ctx.db.artifact.create({
+              data: {
+                workspaceId: input.workspaceId,
+                type: ArtifactType.STUDY_GUIDE,
+                title: files.length === 1 ? `Study Guide - ${primaryFile.name}` : `Study Guide - ${files.length} files`,
+                createdById: ctx.session.user.id,
+              },
+            });
+          }
+
+          const lastVersion = await ctx.db.artifactVersion.findFirst({
+            where: { artifact: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE } },
+            orderBy: { version: 'desc' },
+          });
+
+          await ctx.db.artifactVersion.create({
+            data: { artifactId: artifact.id, version: lastVersion ? lastVersion.version + 1 : 1, content: content, createdById: ctx.session.user.id },
+          });
+
+          results.artifacts.studyGuide = artifact;
+        }
+
+        if (input.generateFlashcards) {
+          await updateAnalysisProgress(ctx.db, input.workspaceId, {
+            status: 'generating_flashcards',
+            filename: primaryFile.name,
+            fileType,
+            startedAt: new Date().toISOString(),
+            steps: {
+              fileUpload: {
+                order: 1,
+                status: 'completed',
+              },
+              fileAnalysis: {
+                order: 2,
+                status: 'completed',
+              },
+              studyGuide: {
+                order: 3,
+                status: input.generateStudyGuide ? 'completed' : 'skipped',
+              },
+              flashcards: {
+                order: 4,
+                status: 'in_progress',
+              },
+            }
+          });
+
+          const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, ctx.session.user.id, 10, 'medium');
+
+          const artifact = await ctx.db.artifact.create({
             data: {
               workspaceId: input.workspaceId,
-              type: ArtifactType.STUDY_GUIDE,
-              title: `Study Guide - ${input.file.filename}`,
+              type: ArtifactType.FLASHCARD_SET,
+              title: files.length === 1 ? `Flashcards - ${primaryFile.name}` : `Flashcards - ${files.length} files`,
               createdById: ctx.session.user.id,
             },
           });
+
+          // Parse JSON flashcard content
+          try {
+            const flashcardData: any = content;
+
+            let createdCards = 0;
+            for (let i = 0; i < Math.min(flashcardData.length, 10); 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,
+                  back: back,
+                  order: i,
+                  tags: ['ai-generated', 'medium'],
+                },
+              });
+              createdCards++;
+            }
+
+          } catch (parseError) {
+            // 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, 10); 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: ['ai-generated', 'medium'],
+                  },
+                });
+              }
+            }
+          }
+
+          results.artifacts.flashcards = artifact;
         }
-                
-        const lastVersion = await ctx.db.artifactVersion.findFirst({
-          where: { artifact: {workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE} },
-          orderBy: { version: 'desc' },
-        });
 
-        await ctx.db.artifactVersion.create({
-          data: { artifactId: artifact.id, version: lastVersion ? lastVersion.version + 1 : 1, content: content, createdById: ctx.session.user.id },
+        await ctx.db.workspace.update({
+          where: { id: input.workspaceId },
+          data: { fileBeingAnalyzed: false },
         });
 
-        results.artifacts.studyGuide = artifact;
-      }
-
-      if (input.generateFlashcards) {
         await updateAnalysisProgress(ctx.db, input.workspaceId, {
-          status: 'generating_flashcards',
-          filename: input.file.filename,
+          status: 'completed',
+          filename: primaryFile.name,
           fileType,
           startedAt: new Date().toISOString(),
+          completedAt: new Date().toISOString(),
           steps: {
             fileUpload: {
               order: 1,
@@ -669,149 +864,71 @@ export const workspace = router({
             },
             flashcards: {
               order: 4,
-              status: 'in_progress',
+              status: input.generateFlashcards ? 'completed' : 'skipped',
             },
           }
+
         });
-        
-        const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, ctx.session.user.id, 10, 'medium');
-        
-        const artifact = await ctx.db.artifact.create({
-          data: {
-            workspaceId: input.workspaceId,
-            type: ArtifactType.FLASHCARD_SET,
-            title: `Flashcards - ${input.file.filename}`,
-            createdById: ctx.session.user.id,
-          },
+        return results;
+      } catch (error) {
+        console.error('❌ Failed to update analysis progress:', error);
+        await ctx.db.workspace.update({
+          where: { id: input.workspaceId },
+          data: { fileBeingAnalyzed: false },
         });
-        
-        // Parse JSON flashcard content
-        try {
-          const flashcardData: any = content;
-          
-          let createdCards = 0;
-          for (let i = 0; i < Math.min(flashcardData.length, 10); 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,
-                back: back,
-                order: i,
-                tags: ['ai-generated', 'medium'],
+        await PusherService.emitError(input.workspaceId, `Failed to update analysis progress: ${error}`, 'file_analysis');
+        throw error;
+      }
+    }),
+  search: authedProcedure
+    .input(z.object({
+      query: z.string(),
+      limit: z.number().min(1).max(100).default(20),
+    }))
+    .query(async ({ ctx, input }) => {
+      const { query } = input;
+      const workspaces = await ctx.db.workspace.findMany({
+        where: {
+          ownerId: ctx.session.user.id,
+          OR: [
+            {
+              title: {
+                contains: query,
+                mode: 'insensitive',
               },
-            });
-            createdCards++;
-          }
-          
-        } catch (parseError) {
-          // 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, 10); 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: ['ai-generated', 'medium'],
-                },
-              });
+            },
+            {
+              description: {
+                contains: query,
+                mode: 'insensitive',
+              },
+            },
+          ],
+        },
+        orderBy: {
+          updatedAt: 'desc',
+        },
+        take: input.limit,
+      });
+
+      // Update analysisProgress for each workspace with search metadata
+      const workspaceUpdates = workspaces.map(ws =>
+        ctx.db.workspace.update({
+          where: { id: ws.id },
+          data: {
+            analysisProgress: {
+              lastSearched: new Date().toISOString(),
+              searchQuery: query,
+              matchedIn: ws.title.toLowerCase().includes(query.toLowerCase()) ? 'title' : 'description',
             }
           }
-        }
-        
-        results.artifacts.flashcards = artifact;
-      }
+        })
+      );
 
-      await ctx.db.workspace.update({
-        where: { id: input.workspaceId },
-        data: { fileBeingAnalyzed: false },
-      });
+      await Promise.all(workspaceUpdates);
 
-      await updateAnalysisProgress(ctx.db, input.workspaceId, {
-        status: 'completed',
-        filename: input.file.filename,
-        fileType,
-        startedAt: new Date().toISOString(),
-        completedAt: new Date().toISOString(),
-        steps: {
-          fileUpload: {
-            order: 1,
-            status: 'completed',
-          },
-          fileAnalysis: {
-            order: 2,
-            status: 'completed',
-          },
-          studyGuide: {
-            order: 3,
-            status: input.generateStudyGuide ? 'completed' : 'skipped',
-          },
-          flashcards: {
-            order: 4,
-            status: input.generateFlashcards ? 'completed' : 'skipped',
-          },
-        }
-      });
-      
-      return results;
+      return workspaces;
     }),
-      search: authedProcedure
-        .input(z.object({
-          query: z.string(),
-          limit: z.number().min(1).max(100).default(20),
-        }))
-        .query(async ({ ctx, input }) => {
-          const { query } = input;
-          const workspaces = await ctx.db.workspace.findMany({
-            where: {
-              ownerId: ctx.session.user.id,
-              OR: [
-                {
-                  title: {
-                    contains: query,
-                    mode: 'insensitive',
-                  },
-                },
-                {
-                  description: {
-                    contains: query,
-                    mode: 'insensitive',
-                  },
-                },
-              ],
-            },
-            orderBy: {
-              updatedAt: 'desc',
-            },
-            take: input.limit,
-          });
-          
-          // Update analysisProgress for each workspace with search metadata
-          const workspaceUpdates = workspaces.map(ws => 
-            ctx.db.workspace.update({
-              where: { id: ws.id },
-              data: {
-                analysisProgress: {
-                  lastSearched: new Date().toISOString(),
-                  searchQuery: query,
-                  matchedIn: ws.title.toLowerCase().includes(query.toLowerCase()) ? 'title' : 'description',
-                }
-              }
-            })
-          );
-          
-          await Promise.all(workspaceUpdates);
-          
-          return workspaces;
-        }),
 
   // Members sub-router
   members,