@goscribe/server 1.3.4 → 1.6.0

package/dist/services/content/copilot.service.js

@@ -0,0 +1,439 @@
+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 { 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),
+});
+const RATE_LIMIT_WINDOW_MS = 60000;
+const RATE_LIMIT_MAX_REQUESTS = 20;
+const requestBuckets = new Map();
+function enforceRateLimit(userId, workspaceId) {
+    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) {
+    return sanitizeString(context.documentContent, 5000000);
+}
+function extractJson(content) {
+    return ai.parse.extractJson(content);
+}
+function getAnswerFromParsedJSON(parsed) {
+    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, anchorDocument) {
+    const parsed = z.array(highlightInstructionSchema).safeParse(raw);
+    if (!parsed.success)
+        return [];
+    const seen = new Set();
+    const results = [];
+    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) {
+    const documentSnippet = contextWindow(params.context);
+    const selectedText = params.context.selectedText
+        ? sanitizeString(params.context.selectedText, 2000)
+        : '';
+    const viewportText = params.context.viewportText
+        ? sanitizeString(params.context.viewportText, 4000)
+        : '';
+    const message = sanitizeString(params.message, 4000);
+    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, 12000)
+        : '';
+    const contextPrompt = [
+        'DOCUMENT:',
+        documentSnippet,
+        '',
+        'PLAIN_DOCUMENT:',
+        plainSnippet || documentSnippet.slice(0, 12000),
+        '',
+        'WORKSPACE_KNOWLEDGE:',
+        ragContext || 'None',
+        '',
+        'SELECTION:',
+        selectedText || 'None',
+        '',
+        'VIEWPORT_TEXT:',
+        viewportText || 'None',
+    ].join('\n');
+    const messages = [
+        { 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) {
+        super(db);
+    }
+    async assertWorkspaceAccess(userId, workspaceId) {
+        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',
+            });
+        }
+    }
+    async assertConversationAccess(userId, workspaceId, conversationId) {
+        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' });
+        }
+    }
+    async loadHistory(conversationId) {
+        if (!conversationId)
+            return [];
+        const messages = await this.db.copilotMessage.findMany({
+            where: { conversationId },
+            orderBy: { createdAt: 'asc' },
+            take: 50,
+        });
+        return messages.map((m) => ({
+            role: m.role.toLowerCase(),
+            content: m.content,
+        }));
+    }
+    async persistConversationExchange(params) {
+        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, 8000),
+                },
+                {
+                    conversationId: params.conversationId,
+                    role: 'ASSISTANT',
+                    content: sanitizeString(params.assistantMessage, 20000),
+                },
+            ],
+        });
+        await this.db.copilotConversation.update({
+            where: { id: params.conversationId },
+            data: {
+                updatedAt: new Date(),
+                ...(shouldUpdateTitle ? { title: generatedTitle } : {}),
+            },
+        });
+    }
+    async listConversations(userId, workspaceId) {
+        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, workspaceId, conversationId) {
+        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, input) {
+        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, workspaceId, conversationId) {
+        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, input) {
+        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, input) {
+        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, input) {
+        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, input) {
+        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/dist/services/content/flashcard-progress.service.d.ts

@@ -0,0 +1,159 @@
+import { Prisma, type PrismaClient } from '@prisma/client';
+import { BaseService } from '../base.service.js';
+/**
+ * SM-2 Spaced Repetition Algorithm
+ * https://www.supermemo.com/en/archives1990-2015/english/ol/sm2
+ */
+export interface SM2Result {
+    easeFactor: number;
+    interval: number;
+    repetitions: number;
+    nextReviewAt: Date;
+}
+export declare class FlashcardProgressService extends BaseService {
+    constructor(db: PrismaClient);
+    /**
+     * Calculate next review using SM-2 algorithm with smart scheduling
+     * @param quality - 0-5 rating (0=complete blackout, 5=perfect response)
+     * @param easeFactor - Current ease factor (default 2.5)
+     * @param interval - Current interval in days (default 0)
+     * @param repetitions - Number of consecutive correct responses (default 0)
+     * @param consecutiveIncorrect - Number of consecutive failures (for smart scheduling)
+     * @param totalIncorrect - Total incorrect count (for context)
+     */
+    calculateSM2(quality: number, easeFactor?: number, interval?: number, repetitions?: number, consecutiveIncorrect?: number, totalIncorrect?: number): SM2Result;
+    /**
+     * Infer confidence level based on consecutive incorrect attempts
+     */
+    inferConfidence(isCorrect: boolean, consecutiveIncorrect: number, timesStudied: number): 'easy' | 'medium' | 'hard';
+    /**
+     * Convert confidence to SM-2 quality rating
+     */
+    confidenceToQuality(confidence: 'easy' | 'medium' | 'hard'): number;
+    /**
+     * Record flashcard study attempt
+     */
+    recordStudyAttempt(data: {
+        userId: string;
+        flashcardId: string;
+        isCorrect: boolean;
+        confidence?: 'easy' | 'medium' | 'hard';
+        timeSpentMs?: number;
+    }, retryCount?: number): Promise<any>;
+    /**
+     * Get user's progress on all flashcards in a set
+     */
+    getSetProgress(userId: string, artifactId: string): Promise<{
+        flashcardId: any;
+        front: any;
+        back: any;
+        progress: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            flashcardId: string;
+            timesStudied: number;
+            timesCorrect: number;
+            timesIncorrect: number;
+            timesIncorrectConsecutive: number;
+            easeFactor: number;
+            interval: number;
+            repetitions: number;
+            masteryLevel: number;
+            lastStudiedAt: Date | null;
+            nextReviewAt: Date | null;
+        } | null;
+    }[]>;
+    /**
+     * Get flashcards due for review, non-studied flashcards, and flashcards with low mastery
+     */
+    getDueFlashcards(userId: string, workspaceId: string): Promise<(({
+        artifact: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            workspaceId: string;
+            type: import("@prisma/client").$Enums.ArtifactType;
+            title: string;
+            isArchived: boolean;
+            difficulty: import("@prisma/client").$Enums.Difficulty | null;
+            estimatedTime: string | null;
+            createdById: string | null;
+            description: string | null;
+            generating: boolean;
+            generatingMetadata: Prisma.JsonValue | null;
+            worksheetConfig: Prisma.JsonValue | null;
+            imageObjectKey: string | null;
+        };
+    } & {
+        id: string;
+        createdAt: Date;
+        artifactId: string;
+        tags: string[];
+        order: number;
+        front: string;
+        back: string;
+        acceptedAnswers: string[];
+    }) | {
+        artifact: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            workspaceId: string;
+            type: import("@prisma/client").$Enums.ArtifactType;
+            title: string;
+            isArchived: boolean;
+            difficulty: import("@prisma/client").$Enums.Difficulty | null;
+            estimatedTime: string | null;
+            createdById: string | null;
+            description: string | null;
+            generating: boolean;
+            generatingMetadata: Prisma.JsonValue | null;
+            worksheetConfig: Prisma.JsonValue | null;
+            imageObjectKey: string | null;
+        };
+        id: string;
+        createdAt: Date;
+        artifactId: string;
+        tags: string[];
+        order: number;
+        front: string;
+        back: string;
+        acceptedAnswers: string[];
+    })[]>;
+    /**
+     * Get user statistics for a flashcard set
+     */
+    getSetStatistics(userId: string, artifactId: string): Promise<{
+        totalCards: number;
+        studiedCards: number;
+        unstudiedCards: number;
+        masteredCards: number;
+        dueForReview: number;
+        averageMastery: number;
+        successRate: number;
+        totalAttempts: number;
+        totalCorrect: number;
+    }>;
+    /**
+     * Reset progress for a flashcard
+     */
+    resetProgress(userId: string, flashcardId: string): Promise<Prisma.BatchPayload>;
+    /**
+     * Bulk record study session
+     */
+    recordStudySession(data: {
+        userId: string;
+        attempts: Array<{
+            flashcardId: string;
+            isCorrect: boolean;
+            confidence?: 'easy' | 'medium' | 'hard';
+            timeSpentMs?: number;
+        }>;
+    }): Promise<any[]>;
+}
+/**
+ * Factory function
+ */
+export declare function createFlashcardProgressService(db: PrismaClient): FlashcardProgressService;