@studious-lms/server 1.14.0 → 1.15.0

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/helpers/registerInput.ts

@@ -0,0 +1,20 @@
+import { CURRENT_TERMS_VERSION } from "../../src/lib/legal.js";
+
+export function registerInput(
+  overrides: {
+    username: string;
+    email: string;
+    password?: string;
+    confirmPassword?: string;
+  },
+) {
+  const password = overrides.password ?? "password_is_1234";
+  return {
+    username: overrides.username,
+    email: overrides.email,
+    password,
+    confirmPassword: overrides.confirmPassword ?? password,
+    agreeToTerms: true as const,
+    termsVersion: CURRENT_TERMS_VERSION,
+  };
+}

package/tests/integration/globalSetup.ts

@@ -10,6 +10,7 @@ import { createTRPCContext } from '../../src/trpc';
 import { clearDatabase } from '../../src/seedDatabase';
 import { execSync } from 'child_process';
 import { SessionType } from '@prisma/client';
+import { registerInput } from '../helpers/registerInput.js';
 
 async function runSetup() {
   const ctx = await createTRPCContext({
@@ -20,26 +21,17 @@ async function runSetup() {
 
   execSync('npm run test:pre');
 
-  const user1 = await caller.auth.register({
-    username: 'testuser1',
-    email: 'test@studious.sh',
-    password: 'password_is_1234',
-    confirmPassword: 'password_is_1234',
-  });
+  const user1 = await caller.auth.register(
+    registerInput({ username: 'testuser1', email: 'test@studious.sh' }),
+  );
 
-  const user2 = await caller.auth.register({
-    username: 'testuser2',
-    email: 'test2@studious.sh',
-    password: 'password_is_1234',
-    confirmPassword: 'password_is_1234',
-  });
+  const user2 = await caller.auth.register(
+    registerInput({ username: 'testuser2', email: 'test2@studious.sh' }),
+  );
 
-  const user3 = await caller.auth.register({
-    username: 'testuser3',
-    email: 'test3@studious.sh',
-    password: 'password_is_1234',
-    confirmPassword: 'password_is_1234',
-  });
+  const user3 = await caller.auth.register(
+    registerInput({ username: 'testuser3', email: 'test3@studious.sh' }),
+  );
 
   const session1 = await prisma.session.findFirst({
     where: { userId: user1.user.id, type: SessionType.EMAIL_VERIFICATION },

package/tests/integration/routers/auth.test.ts

@@ -6,6 +6,7 @@ import { test, expect, describe } from 'vitest';
 import { appRouter } from '../../../src/routers/_app';
 import { createTRPCContext } from '../../../src/trpc';
 import { prisma } from '../../../src/lib/prisma';
+import { registerInput } from '../../helpers/registerInput.js';
 import {
   caller,
   login1,
@@ -64,12 +65,9 @@ describe('Auth Router', () => {
   test('check fails when unauthenticated', () => expectUnauth((c) => c.auth.check()));
 
   test('resendVerificationEmail succeeds for existing user', async () => {
-    await caller.auth.register({
-      username: 'resendtest',
-      email: 'resend@studious.sh',
-      password: 'password_is_1234',
-      confirmPassword: 'password_is_1234',
-    });
+    await caller.auth.register(
+      registerInput({ username: 'resendtest', email: 'resend@studious.sh' }),
+    );
     const result = await caller.auth.resendVerificationEmail({
       email: 'resend@studious.sh',
     });
@@ -227,23 +225,20 @@ describe('Auth Router', () => {
 
   test('register fails when username already exists', async () => {
     await expect(
-      caller.auth.register({
-        username: 'testuser1',
-        email: 'newemail@studious.sh',
-        password: 'password_is_1234',
-        confirmPassword: 'password_is_1234',
-      })
+      caller.auth.register(
+        registerInput({
+          username: 'testuser1',
+          email: 'newemail@studious.sh',
+        }),
+      )
     ).rejects.toThrow();
   });
 
   test('register fails when email already exists', async () => {
     await expect(
-      caller.auth.register({
-        username: 'newuser',
-        email: 'test@studious.sh',
-        password: 'password_is_1234',
-        confirmPassword: 'password_is_1234',
-      })
+      caller.auth.register(
+        registerInput({ username: 'newuser', email: 'test@studious.sh' }),
+      )
     ).rejects.toThrow();
   });
 

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');
+  });
+});

package/tests/unit/services/aiChatStream.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'vitest';
+import {
+  enrichStreamPartsWithGeneratedFiles,
+  finalizeDeferredToolParts,
+} from '../../../src/services/aiChatStream.js';
+
+describe('enrichStreamPartsWithGeneratedFiles', () => {
+  it('links generated files to generate_document tool parts by title', () => {
+    const parts = enrichStreamPartsWithGeneratedFiles(
+      [
+        { type: 'text', text: 'Here is your worksheet.' },
+        {
+          type: 'tool',
+          toolCallId: 'tc-1',
+          toolName: 'generate_document',
+          title: 'Algebra Review',
+          status: 'completed',
+        },
+      ],
+      [{ title: 'Algebra Review', fileId: 'file-1', fileName: 'Algebra_Review.pdf' }],
+    );
+
+    expect(parts[1]).toMatchObject({
+      type: 'tool',
+      fileId: 'file-1',
+      fileName: 'Algebra_Review.pdf',
+    });
+  });
+
+  it('falls back to order when titles do not match', () => {
+    const parts = enrichStreamPartsWithGeneratedFiles(
+      [
+        {
+          type: 'tool',
+          toolCallId: 'tc-1',
+          toolName: 'generate_document',
+          status: 'completed',
+        },
+      ],
+      [{ title: 'Doc A', fileId: 'file-a', fileName: 'doc_a.pdf' }],
+    );
+
+    expect(parts[0]).toMatchObject({ fileId: 'file-a' });
+  });
+
+  it('marks linked generate_document tools completed', () => {
+    const parts = enrichStreamPartsWithGeneratedFiles(
+      [
+        {
+          type: 'tool',
+          toolCallId: 'tc-1',
+          toolName: 'generate_document',
+          title: 'Slides',
+          status: 'executing',
+        },
+      ],
+      [{ title: 'Slides', fileId: 'file-1', fileName: 'slides.pptx' }],
+    );
+
+    expect(parts[0]).toMatchObject({ status: 'completed', fileId: 'file-1' });
+  });
+});
+
+describe('finalizeDeferredToolParts', () => {
+  it('marks generate_document without a file as failed', () => {
+    const parts = finalizeDeferredToolParts([
+      {
+        type: 'tool',
+        toolCallId: 'tc-1',
+        toolName: 'generate_document',
+        title: 'Missing',
+        status: 'executing',
+      },
+    ]);
+
+    expect(parts[0]).toMatchObject({ status: 'failed' });
+  });
+
+  it('leaves other tools unchanged', () => {
+    const parts = finalizeDeferredToolParts([
+      {
+        type: 'tool',
+        toolCallId: 'tc-1',
+        toolName: 'propose_assignment',
+        title: 'HW',
+        status: 'completed',
+      },
+    ]);
+
+    expect(parts[0]).toMatchObject({ status: 'completed' });
+  });
+});

package/tests/unit/services/openaiDocumentGen.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest';
+import {
+  extractContainerGeneratedFiles,
+  mimeTypeForFormat,
+  normalizeDocumentFormat,
+} from '../../../src/services/openaiDocumentGen.js';
+import type { Response } from 'openai/resources/responses/responses.js';
+
+describe('openaiDocumentGen', () => {
+  it('normalizes unknown formats to pdf', () => {
+    expect(normalizeDocumentFormat('docx')).toBe('docx');
+    expect(normalizeDocumentFormat('.PDF')).toBe('pdf');
+    expect(normalizeDocumentFormat('bogus')).toBe('pdf');
+  });
+
+  it('maps formats to mime types', () => {
+    expect(mimeTypeForFormat('pdf')).toBe('application/pdf');
+    expect(mimeTypeForFormat('xlsx')).toBe(
+      'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    );
+    expect(mimeTypeForFormat('png')).toBe('image/png');
+  });
+
+  it('collects container_file_citation annotations for the requested extension', () => {
+    const response = {
+      output: [
+        {
+          type: 'message',
+          content: [
+            {
+              type: 'output_text',
+              text: 'Here is your spreadsheet.',
+              annotations: [
+                {
+                  type: 'container_file_citation',
+                  container_id: 'cntr_1',
+                  file_id: 'cfile_1',
+                  filename: 'Grades.xlsx',
+                  start_index: 0,
+                  end_index: 0,
+                },
+                {
+                  type: 'container_file_citation',
+                  container_id: 'cntr_1',
+                  file_id: 'cfile_2',
+                  filename: 'Notes.pdf',
+                  start_index: 0,
+                  end_index: 0,
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    } as unknown as Response;
+
+    expect(extractContainerGeneratedFiles(response, 'xlsx')).toEqual([
+      {
+        containerId: 'cntr_1',
+        fileId: 'cfile_1',
+        filename: 'Grades.xlsx',
+      },
+    ]);
+  });
+});