@studious-lms/server 1.14.0 → 1.16.0

package/src/services/openaiDocumentGen.ts

@@ -0,0 +1,237 @@
+/**
+ * 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';
+
+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',
+  docx: 'python-docx',
+  doc: 'python-docx',
+  xlsx: 'openpyxl or pandas',
+  pptx: 'python-pptx',
+  csv: 'pandas or csv module',
+  md: 'write markdown directly',
+  html: 'write a complete HTML page',
+  txt: 'write plain text',
+  json: 'json.dumps with indentation',
+  xml: 'well-formed XML',
+  tex: 'LaTeX source',
+  png: 'matplotlib or Pillow',
+  jpeg: 'matplotlib or Pillow',
+  jpg: 'matplotlib or Pillow',
+  gif: 'matplotlib or Pillow',
+  zip: 'zipfile',
+  tar: 'tarfile',
+  py: 'Python source',
+  js: 'JavaScript source',
+  ts: 'TypeScript source',
+  css: 'CSS stylesheet',
+  sh: 'shell script',
+};
+
+export interface GenerateDocumentInput {
+  title: string;
+  content: string;
+  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 extractContainerGeneratedFiles(
+  response: Response,
+  extension: DocumentFormat,
+): ContainerGeneratedFile[] {
+  const suffix = `.${extension}`;
+  const seen = new Set<string>();
+  const files: ContainerGeneratedFile[] = [];
+
+  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)) continue;
+        const key = `${ann.container_id}:${ann.file_id}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        files.push({
+          containerId: ann.container_id,
+          fileId: ann.file_id,
+          filename: 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;
+}
+
+function safeBasename(title: string): string {
+  return (
+    title
+      .replace(/[^a-zA-Z0-9\s\-_]/g, '')
+      .replace(/\s+/g, '_')
+      .substring(0, 60) || 'document'
+  );
+}
+
+/** 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 = format === 'jpg' ? 'jpg' : format;
+  const filename = `${safeBasename(input.title)}.${ext}`;
+
+  try {
+    const response = await client.responses.create({
+      model: DOCUMENT_GEN_MODEL,
+      instructions: [
+        'You generate classroom-ready files for teachers using the python tool.',
+        `You MUST output a ${ext.toUpperCase()} file — not any other format.`,
+        `Use: ${FORMAT_HINTS[format]}.`,
+        `The saved filename MUST end with .${ext}.`,
+        'Save exactly one output file with the requested filename.',
+        'Include only educational content — no chat commentary.',
+        ...(format !== 'pdf' ? [`Do NOT create a PDF when ${ext.toUpperCase()} was requested.`] : []),
+      ].join(' '),
+      tools: [{ type: 'code_interpreter', container: { type: 'auto' } }],
+      tool_choice: 'required',
+      input: [
+        `Create a ${ext.toUpperCase()} file.`,
+        `Filename (exact): ${filename}`,
+        `Title: ${input.title}`,
+        'Content:',
+        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: no output file', {
+        title: input.title,
+        format,
+      });
+      return null;
+    }
+
+    const preferred =
+      matches.find((f) => f.filename.toLowerCase() === filename.toLowerCase()) ??
+      matches[0];
+
+    const res = await client.containers.files.content.retrieve(preferred.fileId, {
+      container_id: preferred.containerId,
+    });
+    const bytes = Buffer.from(await res.arrayBuffer());
+
+    return {
+      bytes,
+      filename: preferred.filename,
+      mimeType: mimeTypeForFormat(format),
+      format,
+    };
+  } catch (error) {
+    logger.error('OpenAI document generation failed', { error, title: input.title, format });
+    return null;
+  }
+}

package/src/services/search.ts

@@ -11,7 +11,9 @@ type SearchScope =
   | "worksheet"
   | "file"
   | "announcement"
-  | "section";
+  | "section"
+  | "discussion"
+  | "submission";
 
 type SearchResult = {
   id: string;
@@ -61,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;
@@ -405,6 +409,9 @@ const SOURCE_TYPE_TO_SCOPE: Record<EmbeddingSourceType, SearchScope> = {
   ANNOUNCEMENT: "announcement",
   FILE: "file",
   SECTION: "section",
+  DISCUSSION: "discussion",
+  SUBMISSION: "submission",
+  SYLLABUS: "syllabus",
 };
 
 const MIN_SIMILARITY = 0.25;
@@ -517,6 +524,23 @@ export async function searchSemanticGlobal(
       });
       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({

package/src/services/worksheet.ts

@@ -3,7 +3,7 @@
  * Integrates with gradeWorksheet pipeline for auto-grading.
  */
 import { TRPCError } from "@trpc/server";
-import { JobStatus, type WorksheetQuestionType } from "@prisma/client";
+import { JobStatus, Prisma, type WorksheetQuestionType } from "@prisma/client";
 import { prisma } from "../lib/prisma.js";
 import { getFileUrl } from "../lib/fileUpload.js";
 import { cancelGradePipeline, regradeWorksheetPipeline } from "../pipelines/gradeWorksheet.js";
@@ -323,6 +323,73 @@ export async function addQuestionToWorksheet(
   });
 }
 
+/** A question's full editable state as captured before an AI modifier run. */
+export interface WorksheetQuestionSnapshot {
+  id: string;
+  type: WorksheetQuestionType;
+  question: string;
+  answer: string;
+  options: unknown;
+  markScheme: unknown;
+  points: number;
+  order: number | null;
+}
+
+const toJsonInput = (value: unknown) =>
+  value === null || value === undefined
+    ? Prisma.JsonNull
+    : (value as Prisma.InputJsonValue);
+
+/**
+ * Restore a worksheet's questions to a snapshot: deletes questions not in the
+ * snapshot, re-creates deleted ones (with their original ids), and reverts
+ * edited ones. Used by AI modifier undo.
+ */
+export async function restoreWorksheetQuestions(
+  worksheetId: string,
+  userId: string,
+  questions: WorksheetQuestionSnapshot[]
+) {
+  const worksheet = await findWorksheetByIdForTeacher(worksheetId, userId);
+  if (!worksheet) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Only class teachers can modify worksheet questions",
+    });
+  }
+
+  await prisma.$transaction([
+    prisma.worksheetQuestion.deleteMany({
+      where: { worksheetId, id: { notIn: questions.map((q) => q.id) } },
+    }),
+    ...questions.map((q) =>
+      prisma.worksheetQuestion.upsert({
+        where: { id: q.id },
+        create: {
+          id: q.id,
+          worksheetId,
+          type: q.type,
+          question: q.question,
+          answer: q.answer,
+          options: toJsonInput(q.options),
+          markScheme: toJsonInput(q.markScheme),
+          points: q.points,
+          order: q.order,
+        },
+        update: {
+          type: q.type,
+          question: q.question,
+          answer: q.answer,
+          options: toJsonInput(q.options),
+          markScheme: toJsonInput(q.markScheme),
+          points: q.points,
+          order: q.order,
+        },
+      })
+    ),
+  ]);
+}
+
 export async function reorderWorksheetQuestions(
   worksheetId: string,
   userId: string,

package/src/workers/processors/embedContent.ts

@@ -1,12 +1,17 @@
 /**
  * Background worker for embedding content into pgvector.
- * Handles indexing of files, assignments, worksheets, and announcements.
+ * Handles indexing of files, assignments, worksheets, announcements,
+ * discussions, submissions, and syllabi.
  */
 import { createRunJobWorker } from './createRunJobWorker.js';
 import {
   indexAssignment,
   indexWorksheet,
   indexAnnouncement,
+  indexDiscussion,
+  indexSubmission,
+  indexSyllabus,
+  indexFile,
   indexContent,
 } from '../../services/embedding.js';
 import { prisma } from '../../lib/prisma.js';
@@ -35,30 +40,21 @@ export const embedContentWorker = createRunJobWorker({
         await indexAnnouncement(classId, sourceId);
         break;
 
-      case 'FILE': {
-        // For files, fetch the file metadata and content
-        const file = await prisma.file.findUnique({
-          where: { id: sourceId },
-          select: { name: true, path: true, type: true },
-        });
+      case 'FILE':
+        await indexFile(classId, sourceId);
+        break;
 
-        if (!file) {
-          logger.warn('File not found for embedding', { sourceId });
-          return { skipped: true, reason: 'file_not_found' };
-        }
+      case 'DISCUSSION':
+        await indexDiscussion(classId, sourceId);
+        break;
 
-        // For now, index the filename and any text-based content.
-        // PDF extraction would be added here with pdf-parse.
-        const text = `File: ${file.name}\nType: ${file.type}\nPath: ${file.path}`;
-        await indexContent({
-          classId,
-          sourceType: 'FILE',
-          sourceId,
-          text,
-          metadata: { name: file.name, type: file.type },
-        });
+      case 'SUBMISSION':
+        await indexSubmission(classId, sourceId);
+        break;
+
+      case 'SYLLABUS':
+        await indexSyllabus(sourceId);
         break;
-      }
 
       case 'SECTION': {
         const section = await prisma.section.findUnique({

package/tests/unit/lib/inferDocumentFormat.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { inferDocumentFormat } from '../../../src/lib/inferDocumentFormat.js';
+
+describe('inferDocumentFormat', () => {
+  it('respects explicit non-pdf format', () => {
+    expect(inferDocumentFormat('Title', 'body', 'xlsx')).toBe('xlsx');
+  });
+
+  it('overrides model pdf when title says presentation', () => {
+    expect(
+      inferDocumentFormat(
+        'Volume of Revolution Presentation',
+        'Slide 1: intro',
+        'pdf',
+      ),
+    ).toBe('pptx');
+  });
+
+  it('uses teacher message for format when model picked pdf', () => {
+    expect(
+      inferDocumentFormat(
+        'Calculus Unit 3',
+        'Content here',
+        'pdf',
+        'Can you make a PowerPoint for this lesson?',
+      ),
+    ).toBe('pptx');
+  });
+
+  it('defaults to pdf for generic handouts', () => {
+    expect(inferDocumentFormat('Reading Guide', 'Chapter summary', 'pdf')).toBe('pdf');
+  });
+});