@goscribe/server 1.3.4 → 1.6.0

package/src/services/content/copilot.service.ts

@@ -0,0 +1,587 @@
+import type { PrismaClient } from '@prisma/client';
+import { TRPCError } from '@trpc/server';
+import { z } from 'zod';
+import { BaseService } from '../base.service.js';
+import { ai } from '../../lib/ai/index.js';
+import { workspaceKbService } from '../workspace/workspace-kb.service.js';
+import { sanitizeString } from '../../lib/validation.js';
+import { workspaceAccessWhere } from '../../repositories/workspace.repository.js';
+import PusherService from '../../lib/pusher.js';
+import { ArtifactType } from '../../lib/constants.js';
+import { FlashcardService } from './flashcard.service.js';
+
+export const copilotArtifactType = z.enum([
+  'study-guide',
+  'worksheet',
+  'flashcards',
+]);
+
+export const copilotContextSchema = z.object({
+  workspaceId: z.string().min(1),
+  artifactId: z.string().min(1),
+  artifactType: copilotArtifactType,
+  documentContent: z.string().min(1),
+  documentPlainText: z.string().optional(),
+  selectedText: z.string().optional(),
+  viewportText: z.string().optional(),
+  cursorPosition: z
+    .object({
+      start: z.number().int().min(0),
+      end: z.number().int().min(0),
+    })
+    .optional(),
+  metadata: z
+    .object({
+      flashcardId: z.string().optional(),
+      questionId: z.string().optional(),
+      documentId: z.string().optional(),
+    })
+    .optional(),
+});
+
+const highlightInstructionSchema = z.object({
+  text: z.string().min(1),
+  label: z.string().optional(),
+});
+
+const flashcardSchema = z.object({
+  front: z.string().min(1),
+  back: z.string().min(1),
+});
+
+export type CopilotContextInput = z.infer<typeof copilotContextSchema>;
+
+const RATE_LIMIT_WINDOW_MS = 60_000;
+const RATE_LIMIT_MAX_REQUESTS = 20;
+const requestBuckets = new Map<string, number[]>();
+
+function enforceRateLimit(userId: string, workspaceId: string) {
+  const now = Date.now();
+  const key = `${userId}:${workspaceId}`;
+  const existing = requestBuckets.get(key) ?? [];
+  const recent = existing.filter((timestamp) => now - timestamp < RATE_LIMIT_WINDOW_MS);
+
+  if (recent.length >= RATE_LIMIT_MAX_REQUESTS) {
+    throw new TRPCError({
+      code: 'TOO_MANY_REQUESTS',
+      message: 'Too many copilot requests. Please wait a moment.',
+    });
+  }
+
+  recent.push(now);
+  requestBuckets.set(key, recent);
+}
+
+function contextWindow(context: CopilotContextInput): string {
+  return sanitizeString(context.documentContent, 5_000_000);
+}
+
+function extractJson(content: string): Record<string, unknown> | null {
+  return ai.parse.extractJson(content);
+}
+
+function getAnswerFromParsedJSON(parsed: Record<string, any> | null): string | null {
+  if (!parsed) return null;
+
+  const potentialKeys = [
+    'answer',
+    'summary',
+    'explanation',
+    'content',
+    'explanationText',
+    'response',
+    'result',
+  ];
+
+  for (const key of potentialKeys) {
+    if (typeof parsed[key] === 'string' && parsed[key].length > 0) {
+      return parsed[key];
+    }
+  }
+
+  return null;
+}
+
+function normalizeHighlightInstructions(
+  raw: unknown,
+  anchorDocument: string,
+): Array<{ text: string; label?: string }> {
+  const parsed = z.array(highlightInstructionSchema).safeParse(raw);
+  if (!parsed.success) return [];
+
+  const seen = new Set<string>();
+  const results: Array<{ text: string; label?: string }> = [];
+
+  for (const item of parsed.data) {
+    const text = sanitizeString(item.text, 800).trim();
+    if (text.length < 2) continue;
+    if (!anchorDocument.includes(text)) continue;
+    const key = text.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    results.push({
+      text,
+      label: item.label ? sanitizeString(item.label, 120) : undefined,
+    });
+  }
+
+  return results;
+}
+
+async function callCopilotModel(params: {
+  mode: 'ask' | 'explainSelection' | 'suggestHighlights' | 'generateFlashcards';
+  context: CopilotContextInput;
+  message: string;
+  history?: { role: 'user' | 'assistant'; content: string }[];
+}) {
+  const documentSnippet = contextWindow(params.context);
+  const selectedText = params.context.selectedText
+    ? sanitizeString(params.context.selectedText, 2_000)
+    : '';
+  const viewportText = params.context.viewportText
+    ? sanitizeString(params.context.viewportText, 4_000)
+    : '';
+  const message = sanitizeString(params.message, 4_000);
+
+  const ragContext = await workspaceKbService.retrieveContext(
+    params.context.workspaceId,
+    message,
+    6,
+  );
+
+  const systemPrompt = [
+    'You are an AI study assistant for the Scribe learning platform.',
+    'Be concise, correct, and safe. Do not claim edits were applied unless asked and confirmed by the user.',
+    'Return valid JSON only.',
+    '',
+    'OUTPUT FORMAT:',
+    '{',
+    '  "answer": "markdown response for the user",',
+    '  "highlights": [{ "text": "exact quote from PLAIN_DOCUMENT", "label": "optional" }],',
+    '  "flashcards": [{ "front": "question", "back": "answer" }]',
+    '}',
+    'Include only relevant keys for the task.',
+    'For highlights: each "text" must be copied verbatim from PLAIN_DOCUMENT. Prefer unique phrases of about 3–40 words, not isolated common words. Do not use numeric start/end offsets.',
+    '',
+    `MODE: ${params.mode}`,
+    `ARTIFACT_TYPE: ${params.context.artifactType}`,
+  ].join('\n');
+
+  const plainSnippet = params.context.documentPlainText
+    ? sanitizeString(params.context.documentPlainText, 12_000)
+    : '';
+
+  const contextPrompt = [
+    'DOCUMENT:',
+    documentSnippet,
+    '',
+    'PLAIN_DOCUMENT:',
+    plainSnippet || documentSnippet.slice(0, 12_000),
+    '',
+    'WORKSPACE_KNOWLEDGE:',
+    ragContext || 'None',
+    '',
+    'SELECTION:',
+    selectedText || 'None',
+    '',
+    'VIEWPORT_TEXT:',
+    viewportText || 'None',
+  ].join('\n');
+
+  const messages: { role: 'system' | 'user' | 'assistant'; content: string }[] = [
+    { role: 'system', content: systemPrompt },
+    { role: 'user', content: contextPrompt },
+  ];
+
+  if (params.history && params.history.length > 0) {
+    params.history.forEach((msg) => {
+      messages.push({
+        role: msg.role === 'user' ? 'user' : 'assistant',
+        content: msg.content,
+      });
+    });
+  }
+
+  messages.push({ role: 'user', content: message });
+
+  const response = await ai.llm.complete(messages);
+  const content = response.choices?.[0]?.message?.content ?? '';
+  const parsed = extractJson(content);
+
+  return { rawContent: content, parsed };
+}
+
+export class CopilotService extends BaseService {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  private async assertWorkspaceAccess(userId: string, workspaceId: string) {
+    const workspace = await this.db.workspace.findFirst({
+      where: { id: workspaceId, ...workspaceAccessWhere(userId) },
+      select: { id: true },
+    });
+    if (!workspace) {
+      throw new TRPCError({
+        code: 'FORBIDDEN',
+        message: 'You do not have access to this workspace',
+      });
+    }
+  }
+
+  private async assertConversationAccess(
+    userId: string,
+    workspaceId: string,
+    conversationId: string,
+  ) {
+    const conversation = await this.db.copilotConversation.findFirst({
+      where: { id: conversationId, workspaceId, userId },
+      select: { id: true },
+    });
+
+    if (!conversation) {
+      throw new TRPCError({ code: 'NOT_FOUND', message: 'Conversation not found' });
+    }
+  }
+
+  private async loadHistory(conversationId?: string) {
+    if (!conversationId) return [] as { role: 'user' | 'assistant'; content: string }[];
+    const messages = await this.db.copilotMessage.findMany({
+      where: { conversationId },
+      orderBy: { createdAt: 'asc' },
+      take: 50,
+    });
+    return messages.map((m) => ({
+      role: m.role.toLowerCase() as 'user' | 'assistant',
+      content: m.content,
+    }));
+  }
+
+  private async persistConversationExchange(params: {
+    userId: string;
+    workspaceId: string;
+    conversationId?: string;
+    userMessage: string;
+    assistantMessage: string;
+  }) {
+    if (!params.conversationId) return;
+
+    await this.assertConversationAccess(params.userId, params.workspaceId, params.conversationId);
+
+    const generatedTitle = sanitizeString(
+      params.userMessage.replace(/\s+/g, ' ').trim(),
+      80,
+    );
+
+    const conversation = await this.db.copilotConversation.findUnique({
+      where: { id: params.conversationId },
+      select: { title: true },
+    });
+
+    const shouldUpdateTitle =
+      !!conversation &&
+      conversation.title.trim().toLowerCase() === 'new chat' &&
+      generatedTitle.length > 0;
+
+    await this.db.copilotMessage.createMany({
+      data: [
+        {
+          conversationId: params.conversationId,
+          role: 'USER',
+          content: sanitizeString(params.userMessage, 8_000),
+        },
+        {
+          conversationId: params.conversationId,
+          role: 'ASSISTANT',
+          content: sanitizeString(params.assistantMessage, 20_000),
+        },
+      ],
+    });
+
+    await this.db.copilotConversation.update({
+      where: { id: params.conversationId },
+      data: {
+        updatedAt: new Date(),
+        ...(shouldUpdateTitle ? { title: generatedTitle } : {}),
+      },
+    });
+  }
+
+  async listConversations(userId: string, workspaceId: string) {
+    await this.assertWorkspaceAccess(userId, workspaceId);
+    const conversations = await this.db.copilotConversation.findMany({
+      where: { workspaceId, userId },
+      include: {
+        messages: { orderBy: { createdAt: 'desc' }, take: 1 },
+      },
+      orderBy: { updatedAt: 'desc' },
+    });
+
+    return conversations.map((conversation) => ({
+      id: conversation.id,
+      title: conversation.title,
+      updatedAt: conversation.updatedAt,
+      preview: conversation.messages[0]?.content ?? '',
+    }));
+  }
+
+  async getConversation(userId: string, workspaceId: string, conversationId: string) {
+    await this.assertWorkspaceAccess(userId, workspaceId);
+    await this.assertConversationAccess(userId, workspaceId, conversationId);
+
+    const conversation = await this.db.copilotConversation.findUnique({
+      where: { id: conversationId },
+      include: { messages: { orderBy: { createdAt: 'asc' } } },
+    });
+
+    if (!conversation) {
+      throw new TRPCError({ code: 'NOT_FOUND', message: 'Conversation not found' });
+    }
+
+    return {
+      id: conversation.id,
+      title: conversation.title,
+      messages: conversation.messages.map((message) => ({
+        id: message.id,
+        role: message.role === 'USER' ? 'user' : 'assistant',
+        content: message.content,
+        createdAt: message.createdAt,
+      })),
+    };
+  }
+
+  async createConversation(userId: string, input: { workspaceId: string; title?: string }) {
+    await this.assertWorkspaceAccess(userId, input.workspaceId);
+
+    const conversation = await this.db.copilotConversation.create({
+      data: {
+        workspaceId: input.workspaceId,
+        userId,
+        title: sanitizeString(input.title || 'New Chat', 120),
+      },
+    });
+
+    return {
+      id: conversation.id,
+      title: conversation.title,
+      updatedAt: conversation.updatedAt,
+    };
+  }
+
+  async deleteConversation(userId: string, workspaceId: string, conversationId: string) {
+    await this.assertWorkspaceAccess(userId, workspaceId);
+    await this.assertConversationAccess(userId, workspaceId, conversationId);
+
+    await this.db.copilotConversation.delete({ where: { id: conversationId } });
+    return { success: true };
+  }
+
+  async ask(
+    userId: string,
+    input: { context: CopilotContextInput; message: string; conversationId?: string },
+  ) {
+    enforceRateLimit(userId, input.context.workspaceId);
+    await this.assertWorkspaceAccess(userId, input.context.workspaceId);
+
+    const history = await this.loadHistory(input.conversationId);
+    const model = await callCopilotModel({
+      mode: 'ask',
+      context: input.context,
+      message: input.message,
+      history,
+    });
+
+    const answer =
+      getAnswerFromParsedJSON(model.parsed) ||
+      model.rawContent ||
+      'I could not generate a response.';
+
+    const safeHighlights = normalizeHighlightInstructions(
+      model.parsed?.highlights,
+      input.context.documentPlainText ?? input.context.documentContent,
+    );
+
+    await this.persistConversationExchange({
+      userId,
+      workspaceId: input.context.workspaceId,
+      conversationId: input.conversationId,
+      userMessage: input.message,
+      assistantMessage: answer,
+    });
+
+    return { answer, highlights: safeHighlights };
+  }
+
+  async explainSelection(
+    userId: string,
+    input: { context: CopilotContextInput; message?: string; conversationId?: string },
+  ) {
+    enforceRateLimit(userId, input.context.workspaceId);
+    await this.assertWorkspaceAccess(userId, input.context.workspaceId);
+
+    const question =
+      input.message && input.message.trim().length > 0
+        ? input.message
+        : 'Explain the selected text in simple study-friendly terms and include one practical example.';
+
+    const history = await this.loadHistory(input.conversationId);
+    const model = await callCopilotModel({
+      mode: 'explainSelection',
+      context: input.context,
+      message: question,
+      history,
+    });
+
+    const answer =
+      getAnswerFromParsedJSON(model.parsed) ||
+      model.rawContent ||
+      'I could not explain this selection.';
+
+    await this.persistConversationExchange({
+      userId,
+      workspaceId: input.context.workspaceId,
+      conversationId: input.conversationId,
+      userMessage: question,
+      assistantMessage: answer,
+    });
+
+    return { answer };
+  }
+
+  async suggestHighlights(
+    userId: string,
+    input: { context: CopilotContextInput; message?: string; conversationId?: string },
+  ) {
+    enforceRateLimit(userId, input.context.workspaceId);
+    await this.assertWorkspaceAccess(userId, input.context.workspaceId);
+
+    await PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:thinking', {
+      status: 'started',
+    });
+
+    const instruction =
+      input.message && input.message.trim().length > 0
+        ? input.message
+        : 'Suggest key highlights. Return exact phrases copied from PLAIN_DOCUMENT (about 3–40 words each).';
+
+    const history = await this.loadHistory(input.conversationId);
+    const model = await callCopilotModel({
+      mode: 'suggestHighlights',
+      context: input.context,
+      message: instruction,
+      history,
+    });
+
+    const safeHighlights = normalizeHighlightInstructions(
+      model.parsed?.highlights,
+      input.context.documentPlainText ?? input.context.documentContent,
+    );
+
+    await PusherService.emitTaskComplete(
+      input.context.workspaceId,
+      'copilot:highlight_suggestions',
+      { highlights: safeHighlights },
+    );
+
+    const answer =
+      getAnswerFromParsedJSON(model.parsed) || 'Here are suggested highlights.';
+
+    await this.persistConversationExchange({
+      userId,
+      workspaceId: input.context.workspaceId,
+      conversationId: input.conversationId,
+      userMessage: instruction,
+      assistantMessage: answer,
+    });
+
+    return { answer, highlights: safeHighlights };
+  }
+
+  async generateFlashcards(
+    userId: string,
+    input: {
+      context: CopilotContextInput;
+      message?: string;
+      numCards: number;
+      conversationId?: string;
+    },
+  ) {
+    enforceRateLimit(userId, input.context.workspaceId);
+    await this.assertWorkspaceAccess(userId, input.context.workspaceId);
+
+    await PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:thinking', {
+      status: 'started',
+    });
+
+    const instruction =
+      input.message && input.message.trim().length > 0
+        ? input.message
+        : `Generate ${input.numCards} concise study flashcards from this context.`;
+
+    const history = await this.loadHistory(input.conversationId);
+    const model = await callCopilotModel({
+      mode: 'generateFlashcards',
+      context: input.context,
+      message: instruction,
+      history,
+    });
+
+    const parsedFlashcards = z.array(flashcardSchema).safeParse(model.parsed?.flashcards);
+    const cards = (parsedFlashcards.success ? parsedFlashcards.data : []).slice(0, input.numCards);
+
+    if (cards.length === 0) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: 'Copilot did not return valid flashcards.',
+      });
+    }
+
+    const flashcardService = new FlashcardService(this.db);
+    const primarySet = await flashcardService.ensurePrimarySet(
+      userId,
+      input.context.workspaceId,
+    );
+    const orderOffset = primarySet.flashcards.reduce(
+      (max, card) => Math.max(max, card.order),
+      -1,
+    );
+
+    await this.db.flashcard.createMany({
+      data: cards.map((card, index) => ({
+        artifactId: primarySet.id,
+        front: sanitizeString(card.front, 200),
+        back: sanitizeString(card.back, 500),
+        order: orderOffset + 1 + index,
+        tags: ['copilot-generated'],
+      })),
+    });
+
+    const artifact = await this.db.artifact.findUniqueOrThrow({
+      where: { id: primarySet.id },
+      include: { flashcards: true },
+    });
+
+    await PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:response', {
+      status: 'completed',
+      flashcardSetId: artifact.id,
+    });
+
+    const answer =
+      getAnswerFromParsedJSON(model.parsed) ||
+      `Generated ${artifact.flashcards.length} flashcards.`;
+
+    await this.persistConversationExchange({
+      userId,
+      workspaceId: input.context.workspaceId,
+      conversationId: input.conversationId,
+      userMessage: instruction,
+      assistantMessage: answer,
+    });
+
+    return {
+      answer,
+      artifactId: artifact.id,
+      flashcards: artifact.flashcards,
+    };
+  }
+}

package/src/services/{flashcard-progress.service.ts → content/flashcard-progress.service.ts}

@@ -1,5 +1,6 @@
 import { Prisma, type PrismaClient } from '@prisma/client';
-import { NotFoundError } from '../lib/errors.js';
+import { NotFoundError } from '../../lib/errors.js';
+import { BaseService } from '../base.service.js';
 
 /**
  * SM-2 Spaced Repetition Algorithm
@@ -12,8 +13,10 @@ export interface SM2Result {
   nextReviewAt: Date;
 }
 
-export class FlashcardProgressService {
-  constructor(private db: PrismaClient) {}
+export class FlashcardProgressService extends BaseService {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
 
   /**
    * Calculate next review using SM-2 algorithm with smart scheduling
@@ -317,25 +320,28 @@ export class FlashcardProgressService {
     const now = new Date();
     const LOW_MASTERY_THRESHOLD = 50; // Consider mastery < 50 as low
 
-    // Get the latest artifact in the workspace
-    const latestArtifact = await this.db.artifact.findFirst({
+    const flashcardSets = await this.db.artifact.findMany({
       where: {
         workspaceId,
         type: 'FLASHCARD_SET',
       },
-      orderBy: {
-        updatedAt: 'desc',
-      },
+      include: { _count: { select: { flashcards: true } } },
+      orderBy: { createdAt: 'asc' },
     });
 
-    if (!latestArtifact) {
+    if (flashcardSets.length === 0) {
       return [];
     }
 
-    // Get all flashcards from the latest artifact
+    const withCards = flashcardSets.filter((set) => set._count.flashcards > 0);
+    const candidates = withCards.length > 0 ? withCards : flashcardSets;
+    const primaryArtifact = candidates.reduce((best, current) =>
+      current._count.flashcards > best._count.flashcards ? current : best,
+    );
+
     const allFlashcards = await this.db.flashcard.findMany({
       where: {
-        artifactId: latestArtifact.id,
+        artifactId: primaryArtifact.id,
       },
       include: {
         artifact: true,
@@ -373,7 +379,7 @@ export class FlashcardProgressService {
           }
         ],
         flashcard: {
-          artifactId: latestArtifact.id,
+          artifactId: primaryArtifact.id,
         },
       },
       include: {