@goscribe/server 1.3.3 → 1.5.0

package/src/services/content/media-analysis.service.ts

@@ -0,0 +1,556 @@
+import type { PrismaClient } from '@prisma/client';
+import { TRPCError } from '@trpc/server';
+import { BaseService } from '../base.service.js';
+import { ArtifactType } from '../../lib/constants.js';
+import { supabaseClient } from '../../lib/storage.js';
+import PusherService from '../../lib/pusher.js';
+import { ai } from '../../lib/ai/index.js';
+import { workspaceKbService } from '../workspace/workspace-kb.service.js';
+import { getUserUsage, getUserPlanLimits } from '../billing/usage.service.js';
+import { notifyArtifactFailed, notifyArtifactReady } from '../notifications/notification.service.js';
+
+type StepStatus = 'pending' | 'in_progress' | 'completed' | 'skipped' | 'error';
+const PIPELINE_STEPS = ['fileUpload', 'fileAnalysis', 'studyGuide', 'flashcards'] as const;
+const PROGRESS_FILENAME_MAX_CHARS = 20;
+
+function truncateProgressFilename(value: string, maxChars: number = PROGRESS_FILENAME_MAX_CHARS): string {
+  if (value.length <= maxChars) return value;
+  return `${value.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+
+function buildCombinedFilenameLabel(fileNames: string[]): string {
+  return truncateProgressFilename(fileNames.join(', '));
+}
+
+function buildProgressSteps(
+  currentStep: typeof PIPELINE_STEPS[number],
+  currentStatus: StepStatus,
+  config: { generateStudyGuide: boolean; generateFlashcards: boolean },
+  overrides?: Partial<Record<typeof PIPELINE_STEPS[number], StepStatus>>,
+): Record<string, { order: number; status: StepStatus }> {
+  const stepIndex = PIPELINE_STEPS.indexOf(currentStep);
+  const steps: Record<string, { order: number; status: StepStatus }> = {};
+
+  for (let i = 0; i < PIPELINE_STEPS.length; i++) {
+    const step = PIPELINE_STEPS[i];
+    let status: StepStatus;
+
+    if (overrides?.[step]) {
+      status = overrides[step]!;
+    } else if (i < stepIndex) {
+      status = 'completed';
+    } else if (i === stepIndex) {
+      status = currentStatus;
+    } else {
+      if (step === 'studyGuide' && !config.generateStudyGuide) {
+        status = 'skipped';
+      } else if (step === 'flashcards' && !config.generateFlashcards) {
+        status = 'skipped';
+      } else {
+        status = 'pending';
+      }
+    }
+
+    steps[step] = { order: i + 1, status };
+  }
+
+  return steps;
+}
+
+function buildProgress(
+  status: string,
+  filename: string,
+  fileType: string,
+  currentStep: typeof PIPELINE_STEPS[number],
+  currentStepStatus: StepStatus,
+  config: { generateStudyGuide: boolean; generateFlashcards: boolean },
+  extra?: Record<string, any>,
+) {
+  return {
+    status,
+    filename,
+    fileType,
+    startedAt: new Date().toISOString(),
+    steps: buildProgressSteps(currentStep, currentStepStatus, config, extra as any),
+    ...extra,
+  };
+}
+
+export interface UploadAndAnalyzeInput {
+  workspaceId: string;
+  files: Array<{ id: string }>;
+  generateStudyGuide: boolean;
+  generateFlashcards: boolean;
+  generateWorksheet: boolean;
+}
+
+export class MediaAnalysisService extends BaseService {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  private async updateAnalysisProgress(workspaceId: string, progress: any) {
+    await this.db.workspace.update({
+      where: { id: workspaceId },
+      data: { analysisProgress: progress },
+    });
+    await PusherService.emitAnalysisProgress(workspaceId, progress);
+  }
+
+  async uploadAndAnalyzeMedia(input: UploadAndAnalyzeInput, userId: string) {
+    const workspace = await this.db.workspace.findFirst({
+      where: { id: input.workspaceId, ownerId: userId },
+    });
+    if (!workspace) {
+      this.logger.error('Workspace not found', { workspaceId: input.workspaceId, userId });
+      throw new TRPCError({ code: 'NOT_FOUND' });
+    }
+
+    if (workspace.fileBeingAnalyzed) {
+      throw new TRPCError({
+        code: 'CONFLICT',
+        message:
+          'File analysis is already in progress for this workspace. Please wait for it to complete.',
+      });
+    }
+
+    const files = await this.db.fileAsset.findMany({
+      where: {
+        id: { in: input.files.map((file) => file.id) },
+        workspaceId: input.workspaceId,
+        userId,
+      },
+    });
+
+    if (files.length === 0) {
+      throw new TRPCError({
+        code: 'NOT_FOUND',
+        message: 'No files found with the provided IDs',
+      });
+    }
+
+    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`,
+        });
+      }
+    }
+
+    const primaryFile = files[0];
+    const fileType = primaryFile.mimeType.startsWith('image/') ? 'image' : 'pdf';
+    const combinedFilenameLabel = buildCombinedFilenameLabel(files.map((file) => file.name));
+
+    try {
+      await this.db.workspace.update({
+        where: { id: input.workspaceId },
+        data: { fileBeingAnalyzed: true },
+      });
+
+      const genConfig = {
+        generateStudyGuide: input.generateStudyGuide,
+        generateFlashcards: input.generateFlashcards,
+      };
+
+      PusherService.emitAnalysisProgress(
+        input.workspaceId,
+        buildProgress('starting', primaryFile.name, fileType, 'fileUpload', 'pending', genConfig),
+      );
+
+      try {
+        await this.updateAnalysisProgress(
+          input.workspaceId,
+          buildProgress('starting', primaryFile.name, fileType, 'fileUpload', 'pending', genConfig),
+        );
+      } catch (error) {
+        this.logger.error('Failed to update analysis progress:', error);
+        await this.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;
+      }
+
+      await this.updateAnalysisProgress(
+        input.workspaceId,
+        buildProgress('uploading', primaryFile.name, fileType, 'fileUpload', 'in_progress', genConfig),
+      );
+
+      for (const [fileIndex, file] of files.entries()) {
+        if (!file.bucket || !file.objectKey) {
+          continue;
+        }
+
+        const currentFileType = file.mimeType.startsWith('image/') ? 'image' : 'pdf';
+        const currentFileLabel = truncateProgressFilename(file.name);
+
+        await this.updateAnalysisProgress(
+          input.workspaceId,
+          buildProgress('uploading', currentFileLabel, currentFileType, 'fileUpload', 'in_progress', genConfig, {
+            currentFileIndex: fileIndex + 1,
+            totalFiles: files.length,
+          }),
+        );
+
+        const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
+          .from(file.bucket)
+          .createSignedUrl(file.objectKey, 24 * 60 * 60);
+
+        if (signedUrlError) {
+          await this.db.workspace.update({
+            where: { id: input.workspaceId },
+            data: { fileBeingAnalyzed: false },
+          });
+          throw new TRPCError({
+            code: 'INTERNAL_SERVER_ERROR',
+            message: `Failed to upload file`,
+          });
+        }
+
+        const fileUrl = signedUrlData.signedUrl;
+        const maxPages = currentFileType === 'pdf' && file.size && file.size > 50 ? 50 : undefined;
+
+        const processResult = await ai.backend.processFile(
+          input.workspaceId,
+          userId,
+          fileUrl,
+          currentFileType,
+          maxPages,
+        );
+
+        if (processResult.status === 'error') {
+          this.logger.error(`Failed to process file ${file.name}:`, processResult.error);
+        } else {
+          this.logger.info(
+            `Successfully processed file ${file.name}: ${processResult.pageCount} pages`,
+          );
+
+          await this.db.fileAsset.update({
+            where: { id: file.id },
+            data: {
+              aiTranscription: {
+                comprehensiveDescription: processResult.comprehensiveDescription,
+                textContent: processResult.textContent,
+                imageDescriptions: processResult.imageDescriptions,
+              },
+            },
+          });
+
+          const indexText =
+            processResult.comprehensiveDescription ??
+            processResult.textContent ??
+            '';
+          if (indexText.trim()) {
+            workspaceKbService.indexTextAsync(input.workspaceId, userId, {
+              sourceType: 'file',
+              sourceId: file.id,
+              name: file.name,
+              text: indexText,
+            });
+          }
+        }
+      }
+
+      await this.updateAnalysisProgress(
+        input.workspaceId,
+        buildProgress('analyzing', combinedFilenameLabel, fileType, 'fileAnalysis', 'in_progress', genConfig),
+      );
+
+      try {
+        await this.updateAnalysisProgress(
+          input.workspaceId,
+          buildProgress('generating_artifacts', combinedFilenameLabel, fileType, 'studyGuide', 'pending', genConfig),
+        );
+      } catch (error) {
+        this.logger.error('Failed to analyze files:', error);
+        await this.updateAnalysisProgress(
+          input.workspaceId,
+          buildProgress('error', combinedFilenameLabel, fileType, 'fileAnalysis', 'error', genConfig, {
+            error: `Failed to analyze ${fileType}: ${error}`,
+            studyGuide: 'skipped',
+            flashcards: 'skipped',
+          }),
+        );
+        await this.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,
+        },
+      };
+
+      try {
+        await ai.backend.initSession(input.workspaceId, userId);
+      } catch (initError) {
+        this.logger.error('Failed to init AI session (continuing with workspace context):', initError);
+      }
+
+      const [usage, limits] = await Promise.all([
+        getUserUsage(userId),
+        getUserPlanLimits(userId),
+      ]);
+
+      if (input.generateStudyGuide) {
+        if (limits && usage.studyGuides >= limits.maxStudyGuides) {
+          await this.updateAnalysisProgress(
+            input.workspaceId,
+            buildProgress('skipped', combinedFilenameLabel, fileType, 'studyGuide', 'skipped', genConfig),
+          );
+          await PusherService.emitError(input.workspaceId, 'Study guide skipped: Limit reached.', 'study_guide');
+          await notifyArtifactFailed(this.db, {
+            userId,
+            workspaceId: input.workspaceId,
+            artifactType: ArtifactType.STUDY_GUIDE,
+            message: 'Study guide was skipped because your plan limit was reached.',
+          }).catch(() => {});
+        } else {
+          try {
+            await this.updateAnalysisProgress(
+              input.workspaceId,
+              buildProgress('generating_study_guide', combinedFilenameLabel, fileType, 'studyGuide', 'in_progress', genConfig),
+            );
+
+            const ragContext = await workspaceKbService.retrieveContext(
+              input.workspaceId,
+              'study guide key concepts definitions explanations examples',
+              8,
+            );
+
+            const content = await ai.backend.generateStudyGuide(
+              input.workspaceId,
+              userId,
+              { ragContext },
+            );
+
+            let artifact = await this.db.artifact.findFirst({
+              where: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE },
+            });
+            if (!artifact) {
+              artifact = await this.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: userId,
+                },
+              });
+            }
+
+            const lastVersion = await this.db.artifactVersion.findFirst({
+              where: { artifact: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE } },
+              orderBy: { version: 'desc' },
+            });
+
+            await this.db.artifactVersion.create({
+              data: {
+                artifactId: artifact.id,
+                version: lastVersion ? lastVersion.version + 1 : 1,
+                content: content,
+                createdById: userId,
+              },
+            });
+
+            results.artifacts.studyGuide = artifact;
+            await PusherService.emitStudyGuideComplete(input.workspaceId, artifact);
+            await notifyArtifactReady(this.db, {
+              userId,
+              workspaceId: input.workspaceId,
+              artifactId: artifact.id,
+              artifactType: ArtifactType.STUDY_GUIDE,
+              title: artifact.title,
+            }).catch(() => {});
+
+            workspaceKbService.indexTextAsync(input.workspaceId, userId, {
+              sourceType: 'study-guide',
+              sourceId: artifact.id,
+              name: artifact.title,
+              text: content,
+            });
+          } catch (sgError) {
+            this.logger.error('Study guide generation failed after retries:', sgError);
+            await PusherService.emitError(
+              input.workspaceId,
+              'Study guide generation failed. Please try regenerating later.',
+              'study_guide',
+            );
+            await notifyArtifactFailed(this.db, {
+              userId,
+              workspaceId: input.workspaceId,
+              artifactType: ArtifactType.STUDY_GUIDE,
+              message: 'Study guide generation failed. Please try regenerating later.',
+            }).catch(() => {});
+          }
+        }
+      }
+
+      if (input.generateFlashcards) {
+        if (limits && usage.flashcards >= limits.maxFlashcards) {
+          await this.updateAnalysisProgress(
+            input.workspaceId,
+            buildProgress('skipped', combinedFilenameLabel, fileType, 'flashcards', 'skipped', genConfig),
+          );
+          await PusherService.emitError(input.workspaceId, 'Flashcards skipped: Limit reached.', 'flashcards');
+          await notifyArtifactFailed(this.db, {
+            userId,
+            workspaceId: input.workspaceId,
+            artifactType: ArtifactType.FLASHCARD_SET,
+            message: 'Flashcards were skipped because your plan limit was reached.',
+          }).catch(() => {});
+        } else {
+          try {
+            const sgStatus = input.generateStudyGuide
+              ? results.artifacts.studyGuide
+                ? 'completed'
+                : 'error'
+              : 'skipped';
+            await this.updateAnalysisProgress(
+              input.workspaceId,
+              buildProgress('generating_flashcards', combinedFilenameLabel, fileType, 'flashcards', 'in_progress', genConfig, {
+                studyGuide: sgStatus,
+              } as any),
+            );
+
+            const flashcardRag = await workspaceKbService.retrieveContext(
+              input.workspaceId,
+              'flashcard key concepts facts definitions questions',
+              8,
+            );
+
+            const content = await ai.backend.generateFlashcardQuestions(
+              input.workspaceId,
+              userId,
+              10,
+              'medium',
+              undefined,
+              { ragContext: flashcardRag },
+            );
+
+            const artifact = await this.db.artifact.create({
+              data: {
+                workspaceId: input.workspaceId,
+                type: ArtifactType.FLASHCARD_SET,
+                title:
+                  files.length === 1
+                    ? `Flashcards - ${primaryFile.name}`
+                    : `Flashcards - ${files.length} files`,
+                createdById: userId,
+              },
+            });
+
+            try {
+              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, 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 this.db.flashcard.create({
+                  data: {
+                    artifactId: artifact.id,
+                    front: front,
+                    back: back,
+                    order: i,
+                    tags: ['ai-generated', 'medium'],
+                  },
+                });
+              }
+            } catch (parseError) {
+              console.error(
+                'Failed to parse flashcard JSON or create cards in workspace router:',
+                parseError,
+              );
+              const lines = content.split('\n').filter((line: string) => 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 this.db.flashcard.create({
+                    data: {
+                      artifactId: artifact.id,
+                      front: front.trim(),
+                      back: back.trim(),
+                      order: i,
+                      tags: ['ai-generated', 'medium'],
+                    },
+                  });
+                }
+              }
+            }
+
+            results.artifacts.flashcards = artifact;
+            await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
+            await notifyArtifactReady(this.db, {
+              userId,
+              workspaceId: input.workspaceId,
+              artifactId: artifact.id,
+              artifactType: ArtifactType.FLASHCARD_SET,
+              title: artifact.title,
+            }).catch(() => {});
+          } catch (fcError) {
+            this.logger.error('Flashcard generation failed after retries:', fcError);
+            await PusherService.emitError(
+              input.workspaceId,
+              'Flashcard generation failed. Please try regenerating later.',
+              'flashcards',
+            );
+            await notifyArtifactFailed(this.db, {
+              userId,
+              workspaceId: input.workspaceId,
+              artifactType: ArtifactType.FLASHCARD_SET,
+              message: 'Flashcard generation failed. Please try regenerating later.',
+            }).catch(() => {});
+          }
+        }
+      }
+
+      await this.db.workspace.update({
+        where: { id: input.workspaceId },
+        data: { fileBeingAnalyzed: false },
+      });
+
+      await this.updateAnalysisProgress(input.workspaceId, {
+        ...buildProgress('completed', combinedFilenameLabel, fileType, 'flashcards', 'completed', genConfig),
+        completedAt: new Date().toISOString(),
+      });
+      return results;
+    } catch (error) {
+      this.logger.error('Failed to update analysis progress:', error);
+      await this.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;
+    }
+  }
+}