@studious-lms/server 1.13.0 → 1.15.0

package/src/services/openaiDocumentGen.ts

@@ -0,0 +1,319 @@
+/**
+ * Generate files via OpenAI Code Interpreter (Responses API).
+ * Supports every format the sandbox can produce (pdf, docx, xlsx, pptx, …).
+ */
+import OpenAI from 'openai';
+import type { Response } from 'openai/resources/responses/responses.js';
+import { logger } from '../utils/logger.js';
+
+const DOCUMENT_GEN_MODEL = 'gpt-4o-mini';
+
+/**
+ * Extensions OpenAI Code Interpreter can read/write in its sandbox.
+ * @see https://developers.openai.com/api/docs/guides/tools-code-interpreter
+ */
+export const SUPPORTED_DOCUMENT_FORMATS = [
+  'pdf',
+  'docx',
+  'doc',
+  'xlsx',
+  'pptx',
+  'csv',
+  'md',
+  'html',
+  'txt',
+  'json',
+  'xml',
+  'tex',
+  'png',
+  'jpeg',
+  'jpg',
+  'gif',
+  'zip',
+  'tar',
+  'py',
+  'js',
+  'ts',
+  'css',
+  'sh',
+] as const;
+
+export type DocumentFormat = (typeof SUPPORTED_DOCUMENT_FORMATS)[number];
+
+const FORMAT_MIME: Record<DocumentFormat, string> = {
+  pdf: 'application/pdf',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  doc: 'application/msword',
+  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  csv: 'text/csv',
+  md: 'text/markdown',
+  html: 'text/html',
+  txt: 'text/plain',
+  json: 'application/json',
+  xml: 'application/xml',
+  tex: 'text/x-tex',
+  png: 'image/png',
+  jpeg: 'image/jpeg',
+  jpg: 'image/jpeg',
+  gif: 'image/gif',
+  zip: 'application/zip',
+  tar: 'application/x-tar',
+  py: 'text/x-python',
+  js: 'text/javascript',
+  ts: 'application/typescript',
+  css: 'text/css',
+  sh: 'application/x-sh',
+};
+
+const FORMAT_HINTS: Record<DocumentFormat, string> = {
+  pdf: 'fpdf2 or reportlab — structured document with headings and body text',
+  docx: 'python-docx — Word document with headings and paragraphs',
+  doc: 'python-docx saving as .doc if supported, otherwise .docx',
+  xlsx: 'openpyxl or pandas — spreadsheet with labelled columns/rows',
+  pptx: 'python-pptx — slides with title + bullet content per slide',
+  csv: 'pandas or csv module — tabular data with headers',
+  md: 'write the markdown file directly',
+  html: 'write a complete, styled HTML page',
+  txt: 'write plain text with clear section breaks',
+  json: 'json.dumps with readable indentation',
+  xml: 'well-formed XML document',
+  tex: 'LaTeX source that compiles to the requested content',
+  png: 'matplotlib or Pillow — chart, diagram, or visual',
+  jpeg: 'matplotlib or Pillow — save as JPEG',
+  jpg: 'matplotlib or Pillow — save as JPEG',
+  gif: 'matplotlib or Pillow — save as GIF',
+  zip: 'zipfile — bundle multiple related files if needed',
+  tar: 'tarfile — archive if multiple files are required',
+  py: 'valid Python source code file',
+  js: 'valid JavaScript source file',
+  ts: 'valid TypeScript source file',
+  css: 'stylesheet file',
+  sh: 'shell script file',
+};
+
+export interface GenerateDocumentInput {
+  title: string;
+  /** Markdown or plain-text source material for the output file. */
+  content: string;
+  /** Output format. Defaults to pdf. */
+  format?: DocumentFormat | string;
+}
+
+export interface GeneratedDocumentResult {
+  bytes: Buffer;
+  filename: string;
+  mimeType: string;
+  format: DocumentFormat;
+}
+
+export interface ContainerGeneratedFile {
+  containerId: string;
+  fileId: string;
+  filename: string;
+}
+
+export function normalizeDocumentFormat(
+  format?: string | null,
+): DocumentFormat {
+  const raw = (format ?? 'pdf').toLowerCase().replace(/^\./, '');
+  if ((SUPPORTED_DOCUMENT_FORMATS as readonly string[]).includes(raw)) {
+    return raw as DocumentFormat;
+  }
+  return 'pdf';
+}
+
+export function mimeTypeForFormat(format: DocumentFormat): string {
+  return FORMAT_MIME[format];
+}
+
+export function extensionForFormat(format: DocumentFormat): string {
+  return format === 'jpg' ? 'jpg' : format;
+}
+
+/** Pull generated-file citations for a given extension out of a Responses output. */
+export function extractContainerGeneratedFiles(
+  response: Response,
+  extension: DocumentFormat,
+): ContainerGeneratedFile[] {
+  const seen = new Set<string>();
+  const files: ContainerGeneratedFile[] = [];
+  const suffix = `.${extension}`;
+
+  const add = (containerId: string, fileId: string, filename: string) => {
+    const key = `${containerId}:${fileId}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    files.push({ containerId, fileId, filename });
+  };
+
+  for (const item of response.output ?? []) {
+    if (item.type !== 'message') continue;
+    for (const block of item.content ?? []) {
+      if (block.type !== 'output_text') continue;
+      for (const ann of block.annotations ?? []) {
+        if (ann.type !== 'container_file_citation') continue;
+        const name = ann.filename?.toLowerCase() ?? '';
+        if (name.endsWith(suffix)) {
+          add(ann.container_id, ann.file_id, ann.filename);
+        }
+      }
+    }
+  }
+
+  return files;
+}
+
+function containerIdFromResponse(response: Response): string | undefined {
+  for (const item of response.output ?? []) {
+    if (item.type === 'code_interpreter_call' && item.container_id) {
+      return item.container_id;
+    }
+  }
+  return undefined;
+}
+
+async function listContainerGeneratedFiles(
+  client: OpenAI,
+  containerId: string,
+  extension: DocumentFormat,
+): Promise<ContainerGeneratedFile[]> {
+  const suffix = `.${extension}`;
+  const files: ContainerGeneratedFile[] = [];
+  for await (const file of client.containers.files.list(containerId)) {
+    const path = file.path?.toLowerCase() ?? '';
+    if (path.endsWith(suffix) && file.source === 'assistant') {
+      files.push({
+        containerId,
+        fileId: file.id,
+        filename: file.path.split('/').pop() ?? file.path,
+      });
+    }
+  }
+  return files;
+}
+
+async function downloadContainerFile(
+  client: OpenAI,
+  file: ContainerGeneratedFile,
+): Promise<Buffer | null> {
+  try {
+    const res = await client.containers.files.content.retrieve(file.fileId, {
+      container_id: file.containerId,
+    });
+    const bytes = await res.arrayBuffer();
+    return Buffer.from(bytes);
+  } catch (error) {
+    logger.error('Failed to download container file', { error, file });
+    return null;
+  }
+}
+
+function safeBasename(title: string): string {
+  const base = title
+    .replace(/[^a-zA-Z0-9\s\-_]/g, '')
+    .replace(/\s+/g, '_')
+    .substring(0, 60);
+  return base || 'document';
+}
+
+function buildDocumentGenInstructions(format: DocumentFormat): string {
+  return [
+    'You are a document generator for K-12 and university teachers.',
+    'When given a title, output format, and source content:',
+    '1. Use the python tool to create exactly ONE output file of the requested type.',
+    `2. For this format use: ${FORMAT_HINTS[format]}.`,
+    `3. You MUST output a ${format.toUpperCase()} file — not any other format.`,
+    `4. The saved filename MUST end with .${extensionForFormat(format)}.`,
+    '5. Structure content clearly — headings, sections, lists, tables/charts as appropriate.',
+    '6. Include the document title prominently where the format allows.',
+    '7. Put ONLY the educational content in the file — no meta commentary.',
+    '8. You MUST save the file to disk in the working directory before you finish.',
+    ...(format !== 'pdf'
+      ? [`9. Do NOT create a PDF when ${format.toUpperCase()} was requested.`]
+      : []),
+  ].join(' ');
+}
+
+/** Generate a file via OpenAI Code Interpreter. */
+export async function generateDocumentWithOpenAI(
+  input: GenerateDocumentInput,
+): Promise<GeneratedDocumentResult | null> {
+  const client = new OpenAI();
+  const format = normalizeDocumentFormat(input.format);
+  const ext = extensionForFormat(format);
+  const filename = `${safeBasename(input.title)}.${ext}`;
+
+  try {
+    const response = await client.responses.create({
+      model: DOCUMENT_GEN_MODEL,
+      instructions: buildDocumentGenInstructions(format),
+      tools: [
+        {
+          type: 'code_interpreter',
+          container: { type: 'auto' },
+        },
+      ],
+      tool_choice: 'required',
+      input: [
+        `Create a ${ext.toUpperCase()} file using the python tool.`,
+        `Output filename (exact): ${filename}`,
+        `Output format: ${ext}`,
+        `Document title: ${input.title}`,
+        'Source content (markdown or plain text — adapt to the output format):',
+        input.content,
+      ].join('\n\n'),
+    });
+
+    let matches = extractContainerGeneratedFiles(response, format);
+
+    if (matches.length === 0) {
+      const containerId = containerIdFromResponse(response);
+      if (containerId) {
+        matches = await listContainerGeneratedFiles(client, containerId, format);
+      }
+    }
+
+    if (matches.length === 0) {
+      logger.error('OpenAI document gen produced no matching files', {
+        title: input.title,
+        format,
+        outputTypes: (response.output ?? []).map((o) => o.type),
+      });
+      return null;
+    }
+
+    const preferred =
+      matches.find((f) => f.filename.toLowerCase() === filename.toLowerCase()) ??
+      matches[0];
+
+    const bytes = await downloadContainerFile(client, preferred);
+    if (!bytes) return null;
+
+    return {
+      bytes,
+      filename: preferred.filename,
+      mimeType: mimeTypeForFormat(format),
+      format,
+    };
+  } catch (error) {
+    logger.error('OpenAI document generation failed', {
+      error,
+      title: input.title,
+      format,
+    });
+    return null;
+  }
+}
+
+/** @deprecated Use {@link generateDocumentWithOpenAI} */
+export async function generatePdfWithOpenAI(
+  input: Omit<GenerateDocumentInput, 'format'>,
+): Promise<Buffer | null> {
+  const result = await generateDocumentWithOpenAI({ ...input, format: 'pdf' });
+  return result?.bytes ?? null;
+}
+
+/** @deprecated Use {@link extractContainerGeneratedFiles} */
+export const extractContainerPdfFiles = (response: Response) =>
+  extractContainerGeneratedFiles(response, 'pdf');

package/src/services/search.ts

@@ -1,4 +1,7 @@
 import { prisma } from "../lib/prisma.js";
+import { generateEmbedding } from "./embedding.js";
+import { logger } from "../utils/logger.js";
+import type { EmbeddingSourceType } from "@prisma/client";
 
 type SearchScope =
   | "class"
@@ -8,7 +11,9 @@ type SearchScope =
   | "worksheet"
   | "file"
   | "announcement"
-  | "section";
+  | "section"
+  | "discussion"
+  | "submission";
 
 type SearchResult = {
   id: string;
@@ -58,6 +63,8 @@ const trimResults = (results: SearchResult[], limit: number) =>
         file: 5,
         announcement: 6,
         section: 7,
+        discussion: 8,
+        submission: 9,
       };
       const priorityDiff = priority[a.type] - priority[b.type];
       if (priorityDiff !== 0) return priorityDiff;
@@ -395,3 +402,158 @@ export async function searchGlobalClasses(
 
   return { query, results: trimResults(results, limit) };
 }
+
+const SOURCE_TYPE_TO_SCOPE: Record<EmbeddingSourceType, SearchScope> = {
+  ASSIGNMENT: "assignment",
+  WORKSHEET: "worksheet",
+  ANNOUNCEMENT: "announcement",
+  FILE: "file",
+  SECTION: "section",
+  DISCUSSION: "discussion",
+  SUBMISSION: "submission",
+  SYLLABUS: "syllabus",
+};
+
+const MIN_SIMILARITY = 0.25;
+
+/**
+ * Cross-class semantic search via pgvector.
+ * Generates an embedding for `query`, searches across all classes the user
+ * belongs to, and maps hits back to SearchResult shape.
+ */
+export async function searchSemanticGlobal(
+  userId: string,
+  input: { query: string; limit?: number },
+) {
+  const query = input.query.trim().slice(0, 200);
+  if (!query) {
+    return { query, results: [] as SearchResult[] };
+  }
+  const limit = Math.min(Math.max(input.limit ?? SEARCH_LIMIT, 1), 30);
+
+  const memberships = await prisma.class.findMany({
+    where: {
+      OR: [
+        { teachers: { some: { id: userId } } },
+        { students: { some: { id: userId } } },
+      ],
+    },
+    select: { id: true, name: true },
+  });
+  const allClassIds = memberships.map((cls) => cls.id);
+  if (allClassIds.length === 0) {
+    return { query, results: [] as SearchResult[] };
+  }
+  const classById = new Map(memberships.map((cls) => [cls.id, cls]));
+
+  let queryVector: number[];
+  try {
+    queryVector = await generateEmbedding(query);
+  } catch (err) {
+    logger.error("Semantic search embedding failed", { err });
+    return { query, results: [] as SearchResult[] };
+  }
+
+  const vectorStr = `[${queryVector.join(",")}]`;
+
+  type SemanticRow = {
+    sourceType: EmbeddingSourceType;
+    sourceId: string;
+    classId: string;
+    content: string;
+    similarity: number;
+  };
+
+  const hits = await prisma.$queryRaw<SemanticRow[]>`
+    SELECT DISTINCT ON ("sourceType", "sourceId")
+      "sourceType",
+      "sourceId",
+      "classId",
+      content,
+      1 - (vector <=> ${vectorStr}::vector) as similarity
+    FROM "Embedding"
+    WHERE "classId" = ANY(${allClassIds}::text[])
+    ORDER BY "sourceType", "sourceId", vector <=> ${vectorStr}::vector
+    LIMIT ${limit * 3}
+  `;
+
+  const filtered = hits
+    .filter((h) => h.similarity >= MIN_SIMILARITY)
+    .sort((a, b) => b.similarity - a.similarity)
+    .slice(0, limit);
+
+  const results: SearchResult[] = [];
+  for (const hit of filtered) {
+    const cls = classById.get(hit.classId);
+    const className = cls?.name ?? "Class";
+    const scope = SOURCE_TYPE_TO_SCOPE[hit.sourceType];
+    if (!scope) continue;
+
+    const snippet = hit.content.replace(/\s+/g, " ").trim().slice(0, 140);
+
+    let title = snippet.slice(0, 60);
+    let href = `/class/${hit.classId}`;
+
+    if (scope === "assignment") {
+      const assignment = await prisma.assignment.findUnique({
+        where: { id: hit.sourceId },
+        select: { title: true },
+      });
+      title = assignment?.title ?? title;
+      href = `/class/${hit.classId}/assignment/${hit.sourceId}`;
+    } else if (scope === "worksheet") {
+      const worksheet = await prisma.worksheet.findUnique({
+        where: { id: hit.sourceId },
+        select: { name: true },
+      });
+      title = worksheet?.name ?? title;
+      href = `/class/${hit.classId}/worksheets`;
+    } else if (scope === "announcement") {
+      href = `/class/${hit.classId}`;
+    } else if (scope === "file") {
+      const file = await prisma.file.findUnique({
+        where: { id: hit.sourceId },
+        select: { name: true },
+      });
+      title = file?.name ?? title;
+      href = `/class/${hit.classId}/files`;
+    } else if (scope === "section") {
+      const section = await prisma.section.findUnique({
+        where: { id: hit.sourceId },
+        select: { name: true },
+      });
+      title = section?.name ?? title;
+      href = `/class/${hit.classId}/assignments`;
+    } else if (scope === "discussion") {
+      const discussion = await prisma.discussion.findUnique({
+        where: { id: hit.sourceId },
+        select: { title: true },
+      });
+      title = discussion?.title ?? title;
+      href = `/class/${hit.classId}/discussions/${hit.sourceId}`;
+    } else if (scope === "submission") {
+      const submission = await prisma.submission.findUnique({
+        where: { id: hit.sourceId },
+        select: { assignment: { select: { title: true, id: true } } },
+      });
+      title = submission?.assignment.title ? `Submission: ${submission.assignment.title}` : title;
+      href = submission?.assignment.id ? `/class/${hit.classId}/assignment/${submission.assignment.id}` : href;
+    } else if (scope === "syllabus") {
+      title = `${className} Syllabus`;
+      href = `/class/${hit.classId}/syllabus`;
+    }
+
+    results.push({
+      id: `semantic:${hit.sourceId}`,
+      type: scope,
+      title,
+      subtitle: `${className} · ${scope.charAt(0).toUpperCase() + scope.slice(1)}`,
+      classId: hit.classId,
+      className,
+      href,
+      matchedText: snippet,
+    });
+  }
+
+  return { query, results };
+}

package/src/services/user.ts

@@ -5,15 +5,7 @@ import { TRPCError } from "@trpc/server";
 import { logger } from "../utils/logger.js";
 import { env } from "../lib/config/env.js";
 import { findUserById, findUserProfileByUserId, upsertUserProfile } from "../models/user.js";
-
-function getFileUrl(filePath: string | null): string | null {
-  if (!filePath) return null;
-  if (filePath.startsWith("http")) {
-    return filePath;
-  }
-  const backendUrl = env.BACKEND_URL || "http://localhost:3001";
-  return `${backendUrl}/api/files/${encodeURIComponent(filePath)}`;
-}
+import { makeFilePublic } from "../lib/googleCloudStorage.js";
 
 /** Get user profile with display info and profile picture URLs. */
 export async function getProfile(userId: string) {
@@ -36,10 +28,8 @@ export async function getProfile(userId: string) {
           bio: (userProfile as any).bio || null,
           location: (userProfile as any).location || null,
           website: (userProfile as any).website || null,
-          profilePicture: getFileUrl((userProfile as any).profilePicture),
-          profilePictureThumbnail: getFileUrl(
-            (userProfile as any).profilePictureThumbnail
-          ),
+          profilePicture: (userProfile as any).profilePicture ?? null,
+          profilePictureThumbnail: (userProfile as any).profilePictureThumbnail ?? null,
         }
       : {
           displayName: null,
@@ -78,6 +68,10 @@ export async function updateProfile(
     try {
       profilePictureUrl = input.profilePicture.filePath;
       profilePictureThumbnail = null;
+
+      // Best-effort: make the uploaded file publicly readable so the public
+      // GCS URL resolved by the Prisma extension actually works.
+      await makeFilePublic(profilePictureUrl);
     } catch (error) {
       logger.error("Profile picture processing failed", {
         userId,
@@ -125,10 +119,8 @@ export async function updateProfile(
       bio: (updatedProfile as any).bio || null,
       location: (updatedProfile as any).location || null,
       website: (updatedProfile as any).website || null,
-      profilePicture: getFileUrl((updatedProfile as any).profilePicture),
-      profilePictureThumbnail: getFileUrl(
-        (updatedProfile as any).profilePictureThumbnail
-      ),
+      profilePicture: (updatedProfile as any).profilePicture ?? null,
+      profilePictureThumbnail: (updatedProfile as any).profilePictureThumbnail ?? null,
     },
   };
 }