@studious-lms/server 1.25.0 → 1.27.0

package/src/services/labChat.ts

@@ -11,6 +11,7 @@ import {
   findLabChatByMember,
   findLabChatByTeacher,
   findLabChatById,
+  findClassContextForStarterPrompts,
   findClassMembership,
   findLabChatsByClass,
   findLabChatForPost,
@@ -203,6 +204,70 @@ export async function getLabChat(userId: string, labChatId: string) {
   };
 }
 
+const GENERIC_STARTER_PROMPTS = [
+  "Create a quiz on this week's topic",
+  "Draft a worksheet with 10 practice questions",
+  "Plan a lesson with objectives and activities",
+  "Suggest an assignment with a mark scheme",
+];
+
+const MAX_STARTER_PROMPTS = 5;
+
+/**
+ * Suggest starter prompts for a class's lab chat, derived from recent
+ * class context (upcoming due work, recent assignments, units, subject).
+ * Pure heuristics — no LLM call — so it stays cheap and fast. Falls back
+ * to generic defaults when the class has no usable context.
+ */
+export async function getStarterPrompts(userId: string, classId: string) {
+  const classContext = await findClassContextForStarterPrompts(
+    classId,
+    userId
+  );
+  if (!classContext) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Not a teacher in this class",
+    });
+  }
+
+  const prompts: string[] = [];
+  const now = new Date();
+
+  const published = classContext.assignments.filter((a) => !a.inProgress);
+  const upcoming = published
+    .filter((a) => a.dueDate > now)
+    .sort((a, b) => a.dueDate.getTime() - b.dueDate.getTime())[0];
+  if (upcoming) {
+    prompts.push(
+      `Create a worksheet to help students prepare for "${upcoming.title}"`
+    );
+  }
+
+  const recent = published.find((a) => a.title !== upcoming?.title);
+  if (recent) {
+    prompts.push(`Draft a quiz reviewing "${recent.title}"`);
+  }
+
+  const unit = classContext.sections[0];
+  if (unit) {
+    prompts.push(`Plan a lesson for the unit "${unit.name}"`);
+  }
+
+  if (classContext.subject) {
+    prompts.push(
+      `Suggest a ${classContext.subject} assignment with a mark scheme`
+    );
+  }
+
+  for (const generic of GENERIC_STARTER_PROMPTS) {
+    if (prompts.length >= 3) break;
+    if (!prompts.includes(generic)) prompts.push(generic);
+  }
+
+  return { prompts: prompts.slice(0, MAX_STARTER_PROMPTS) };
+}
+
 export async function listLabChats(userId: string, classId: string) {
   const classMembership = await findClassMembership(classId, userId);
   if (!classMembership) {

package/src/services/marketplace.ts

@@ -21,6 +21,7 @@ import {
   incrementMarketplaceReportCount,
   searchMarketplaceListings,
   setMarketplaceListingHidden,
+  updateMarketplaceListing,
 } from "../models/marketplace.js";
 import {
   findActiveSchoolAdminMembership,
@@ -659,6 +660,44 @@ export async function reportMarketplaceListing(
   return incrementMarketplaceReportCount(listingId);
 }
 
+export async function updateMarketplaceListingDetails(
+  userId: string,
+  input: {
+    listingId: string;
+    title?: string;
+    description?: string | null;
+    visibility?: "SCHOOL" | "PUBLIC";
+    tags?: string[];
+  }
+) {
+  const listing = await findMarketplaceListingById(input.listingId);
+  if (!listing) {
+    throw new TRPCError({ code: "NOT_FOUND", message: "Listing not found" });
+  }
+  const isAuthor = listing.authorId === userId;
+  const isSchoolAdmin =
+    listing.schoolId != null &&
+    Boolean(await findActiveSchoolAdminMembership(listing.schoolId, userId));
+  if (!isAuthor && !isSchoolAdmin) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Only the author or a school admin can edit this listing",
+    });
+  }
+  if (input.visibility === "SCHOOL" && listing.schoolId == null) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Listing has no school; it cannot use school visibility",
+    });
+  }
+  return updateMarketplaceListing(input.listingId, {
+    title: input.title,
+    description: input.description,
+    visibility: input.visibility,
+    tags: input.tags ? normalizeTags(input.tags) : undefined,
+  });
+}
+
 export async function hideMarketplaceListing(
   userId: string,
   listingId: string,

package/src/services/message.ts

@@ -4,6 +4,9 @@
  */
 import type { AppTransactionClient } from "../lib/prisma.js";
 import { TRPCError } from "@trpc/server";
+import { JobStatus, type AiMessageFeedback } from "@prisma/client";
+import { isAIUser } from "../utils/aiUser.js";
+import { enqueueRunJob } from "../workers/queues.js";
 import { prisma } from "../lib/prisma.js";
 import { chatChannel, pusher } from "../lib/pusher.js";
 import {
@@ -181,6 +184,7 @@ export async function listMessages(
       createdAt: message.createdAt,
       sender: message.sender,
       status: message.status,
+      aiFeedback: message.aiFeedback,
       attachments: message.attachments,
       meta: message.meta as Record<string, unknown>,
       mentions: message.mentions.map((m) => ({ user: m.user })),
@@ -512,148 +516,6 @@ export async function deleteMessage(userId: string, messageId: string) {
   return { success: true, messageId };
 }
 
-const CREATED_INDICES_KEY: Record<"assignment" | "worksheet" | "section", string> = {
-  assignment: "assignments",
-  worksheet: "worksheets",
-  section: "sections",
-};
-
-const MARK_SUGGESTION_MAX_RETRIES = 5;
-
-/** Mark an AI-suggested item as created. Stores in message meta for fast reads. */
-export async function markSuggestionCreated(
-  userId: string,
-  input: {
-    messageId: string;
-    type: "assignment" | "worksheet" | "section";
-    index: number;
-  }
-) {
-  const { messageId, type, index } = input;
-
-  const existingMessage = await findMessageByIdMinimal(messageId);
-  if (!existingMessage) {
-    throw new TRPCError({
-      code: "NOT_FOUND",
-      message: "Message not found",
-    });
-  }
-
-  const membership = await findConversationMembership(
-    existingMessage.conversationId,
-    userId
-  );
-  if (!membership) {
-    throw new TRPCError({
-      code: "FORBIDDEN",
-      message: "Not a member of this conversation",
-    });
-  }
-
-  const conversationId = existingMessage.conversationId;
-  let lastError: Error | null = null;
-
-  for (let attempt = 0; attempt < MARK_SUGGESTION_MAX_RETRIES; attempt++) {
-    const msg = await prisma.message.findUnique({
-      where: { id: messageId },
-      select: { meta: true },
-    });
-    if (!msg) {
-      throw new TRPCError({
-        code: "NOT_FOUND",
-        message: "Message not found",
-      });
-    }
-
-    const currentMeta = (msg.meta as Record<string, unknown>) ?? {};
-    const createdIndices = (currentMeta.createdIndices as Record<string, number[]>) ?? {};
-    const typeIndices = createdIndices[CREATED_INDICES_KEY[type]] ?? [];
-    if (typeIndices.includes(index)) return { success: true };
-
-    const newTypeIndices = [...typeIndices, index].sort((a, b) => a - b);
-    const newMeta = {
-      ...currentMeta,
-      createdIndices: {
-        ...createdIndices,
-        [CREATED_INDICES_KEY[type]]: newTypeIndices,
-      },
-    };
-
-    const newMetaJson = JSON.stringify(newMeta);
-    const currentMetaJson = msg.meta === null ? null : JSON.stringify(msg.meta);
-
-    const updatedCount =
-      currentMetaJson === null
-        ? await prisma.$executeRaw`
-            UPDATE "Message" SET meta = ${newMetaJson}::jsonb
-            WHERE id = ${messageId} AND meta IS NULL
-          `
-        : await prisma.$executeRaw`
-            UPDATE "Message" SET meta = ${newMetaJson}::jsonb
-            WHERE id = ${messageId} AND meta = ${currentMetaJson}::jsonb
-          `;
-
-    if (Number(updatedCount) > 0) {
-      const updated = await prisma.message.findUnique({
-        where: { id: messageId },
-        include: {
-          sender: {
-            select: {
-              id: true,
-              username: true,
-              profile: {
-                select: { displayName: true, profilePicture: true },
-              },
-            },
-          },
-          attachments: { select: messageFileSelect },
-          mentions: { select: { userId: true } },
-        },
-      });
-
-      if (updated) {
-        const mentionedUserIds = updated.mentions.map((m) => m.userId);
-        try {
-          await pusher.trigger(
-            chatChannel(conversationId),
-            "message-updated",
-            {
-              id: updated.id,
-              content: updated.content,
-              senderId: updated.senderId,
-              conversationId: updated.conversationId,
-              status: updated.status,
-              createdAt: updated.createdAt,
-              sender: updated.sender,
-              attachments: updated.attachments ?? [],
-              meta: newMeta,
-              mentionedUserIds,
-            }
-          );
-        } catch (error) {
-          logger.error("Failed to broadcast suggestion status via Pusher", {
-            error,
-            messageId,
-          });
-        }
-      }
-      return { success: true };
-    }
-
-    lastError = new Error("Concurrent update conflict");
-  }
-
-  logger.error("markSuggestionCreated failed after retries", {
-    messageId,
-    type,
-    index,
-    error: lastError,
-  });
-  throw new TRPCError({
-    code: "CONFLICT",
-    message: "Failed to update suggestion status after retries due to concurrent updates",
-  });
-}
 
 export async function markAsRead(userId: string, conversationId: string) {
   const membership = await findConversationMembership(conversationId, userId);
@@ -757,3 +619,204 @@ export async function getUnreadCount(
 
   return { unreadCount, unreadMentionCount };
 }
+
+/**
+ * Regenerate an AI response in a lab or Newton chat.
+ *
+ * The existing AI bubble is reused (not deleted): the row flips back to
+ * PENDING with cleared content/meta/feedback so the message id stays stable
+ * for the client, then the matching pipeline refills it. Only the latest
+ * message in the conversation can be regenerated — the pipelines build
+ * their context from the messages preceding the placeholder.
+ */
+export async function regenerateAIResponse(userId: string, messageId: string) {
+  const message = await prisma.message.findUnique({
+    where: { id: messageId },
+    select: {
+      id: true,
+      senderId: true,
+      conversationId: true,
+      status: true,
+      conversation: {
+        select: {
+          labChat: { select: { id: true, classId: true } },
+          newtonChat: { select: { id: true } },
+        },
+      },
+    },
+  });
+  if (!message) {
+    throw new TRPCError({ code: "NOT_FOUND", message: "Message not found" });
+  }
+
+  const membership = await findConversationMembership(
+    message.conversationId,
+    userId
+  );
+  if (!membership) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Not a member of this conversation",
+    });
+  }
+
+  if (!isAIUser(message.senderId)) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Only AI messages can be regenerated",
+    });
+  }
+
+  const { labChat, newtonChat } = message.conversation;
+  if (!labChat && !newtonChat) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "This conversation has no AI pipeline to regenerate with",
+    });
+  }
+
+  if (message.status === JobStatus.PENDING) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "This response is still being generated",
+    });
+  }
+
+  const latestMessage = await prisma.message.findFirst({
+    where: { conversationId: message.conversationId },
+    orderBy: { createdAt: "desc" },
+    select: { id: true },
+  });
+  if (latestMessage?.id !== message.id) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Only the latest AI response can be regenerated",
+    });
+  }
+
+  const reusedAiMessage = await prisma.message.update({
+    where: { id: message.id },
+    data: {
+      content: "",
+      status: JobStatus.PENDING,
+      meta: {},
+      aiFeedback: null,
+    },
+    select: {
+      id: true,
+      content: true,
+      senderId: true,
+      conversationId: true,
+      status: true,
+      createdAt: true,
+    },
+  });
+
+  // Tell the chat UI the existing AI bubble is regenerating — content
+  // cleared, status flipped back to PENDING, same id.
+  try {
+    await pusher.trigger(
+      chatChannel(message.conversationId),
+      "message-updated",
+      {
+        id: reusedAiMessage.id,
+        content: reusedAiMessage.content,
+        senderId: reusedAiMessage.senderId,
+        conversationId: reusedAiMessage.conversationId,
+        status: reusedAiMessage.status,
+        createdAt: reusedAiMessage.createdAt,
+        sender: {
+          id: reusedAiMessage.senderId,
+          username: "Newton_AI",
+          profile: { displayName: "Newton AI", profilePicture: null },
+        },
+        mentionedUserIds: [],
+        meta: {},
+        attachments: [],
+      }
+    );
+  } catch (error) {
+    logger.error("Failed to broadcast AI regenerate reset", {
+      error,
+      messageId,
+    });
+  }
+
+  try {
+    if (labChat) {
+      await enqueueRunJob(
+        "AI_LAB_CHAT",
+        { conversationId: message.conversationId, aiMessageId: reusedAiMessage.id },
+        { classId: labChat.classId, userId }
+      );
+    } else {
+      await enqueueRunJob(
+        "AI_NEWTON_CHAT",
+        { conversationId: message.conversationId, aiMessageId: reusedAiMessage.id },
+        { userId }
+      );
+    }
+  } catch (error) {
+    logger.error("Failed to enqueue AI regeneration", {
+      error,
+      messageId,
+      conversationId: message.conversationId,
+    });
+    throw new TRPCError({
+      code: "INTERNAL_SERVER_ERROR",
+      message: "Failed to start regeneration",
+    });
+  }
+
+  return { success: true, messageId: reusedAiMessage.id };
+}
+
+/** Record (or clear) thumbs up/down feedback on an AI message. */
+export async function setAIMessageFeedback(
+  userId: string,
+  input: {
+    messageId: string;
+    feedback: AiMessageFeedback | null;
+  }
+) {
+  const message = await prisma.message.findUnique({
+    where: { id: input.messageId },
+    select: { id: true, senderId: true, conversationId: true, status: true },
+  });
+  if (!message) {
+    throw new TRPCError({ code: "NOT_FOUND", message: "Message not found" });
+  }
+
+  const membership = await findConversationMembership(
+    message.conversationId,
+    userId
+  );
+  if (!membership) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Not a member of this conversation",
+    });
+  }
+
+  if (!isAIUser(message.senderId)) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Feedback can only be left on AI messages",
+    });
+  }
+
+  if (message.status !== JobStatus.COMPLETED) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Feedback can only be left on completed AI responses",
+    });
+  }
+
+  const updated = await prisma.message.update({
+    where: { id: message.id },
+    data: { aiFeedback: input.feedback },
+    select: { id: true, aiFeedback: true },
+  });
+
+  return { success: true, messageId: updated.id, feedback: updated.aiFeedback };
+}