@goscribe/server 1.3.3 → 1.5.0

package/dist/services/copilot.service.d.ts

@@ -0,0 +1,116 @@
+import type { PrismaClient } from '@prisma/client';
+import { z } from 'zod';
+import { BaseService } from './base.service.js';
+export declare const copilotArtifactType: z.ZodEnum<{
+    flashcards: "flashcards";
+    worksheet: "worksheet";
+    "study-guide": "study-guide";
+    notes: "notes";
+}>;
+export declare const copilotContextSchema: z.ZodObject<{
+    workspaceId: z.ZodString;
+    artifactId: z.ZodString;
+    artifactType: z.ZodEnum<{
+        flashcards: "flashcards";
+        worksheet: "worksheet";
+        "study-guide": "study-guide";
+        notes: "notes";
+    }>;
+    documentContent: z.ZodString;
+    selectedText: z.ZodOptional<z.ZodString>;
+    viewportText: z.ZodOptional<z.ZodString>;
+    cursorPosition: z.ZodOptional<z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        flashcardId: z.ZodOptional<z.ZodString>;
+        questionId: z.ZodOptional<z.ZodString>;
+        documentId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CopilotContextInput = z.infer<typeof copilotContextSchema>;
+export declare class CopilotService extends BaseService {
+    constructor(db: PrismaClient);
+    private assertWorkspaceAccess;
+    private assertConversationAccess;
+    private loadHistory;
+    private persistConversationExchange;
+    listConversations(userId: string, workspaceId: string): Promise<{
+        id: string;
+        title: string;
+        updatedAt: Date;
+        preview: string;
+    }[]>;
+    getConversation(userId: string, workspaceId: string, conversationId: string): Promise<{
+        id: string;
+        title: string;
+        messages: {
+            id: string;
+            role: string;
+            content: string;
+            createdAt: Date;
+        }[];
+    }>;
+    createConversation(userId: string, input: {
+        workspaceId: string;
+        title?: string;
+    }): Promise<{
+        id: string;
+        title: string;
+        updatedAt: Date;
+    }>;
+    deleteConversation(userId: string, workspaceId: string, conversationId: string): Promise<{
+        success: boolean;
+    }>;
+    ask(userId: string, input: {
+        context: CopilotContextInput;
+        message: string;
+        conversationId?: string;
+    }): Promise<{
+        answer: string;
+        highlights: {
+            start: number;
+            end: number;
+            label?: string | undefined;
+        }[];
+    }>;
+    explainSelection(userId: string, input: {
+        context: CopilotContextInput;
+        message?: string;
+        conversationId?: string;
+    }): Promise<{
+        answer: string;
+    }>;
+    suggestHighlights(userId: string, input: {
+        context: CopilotContextInput;
+        message?: string;
+        conversationId?: string;
+    }): Promise<{
+        answer: string;
+        highlights: {
+            start: number;
+            end: number;
+            label?: string | undefined;
+        }[];
+    }>;
+    generateFlashcards(userId: string, input: {
+        context: CopilotContextInput;
+        message?: string;
+        numCards: number;
+        conversationId?: string;
+    }): Promise<{
+        answer: string;
+        artifactId: string;
+        flashcards: {
+            id: string;
+            createdAt: Date;
+            artifactId: string;
+            order: number;
+            front: string;
+            back: string;
+            tags: string[];
+            acceptedAnswers: string[];
+        }[];
+    }>;
+}

package/dist/services/copilot.service.js

@@ -0,0 +1,447 @@
+import { TRPCError } from '@trpc/server';
+import { z } from 'zod';
+import { BaseService } from './base.service.js';
+import inference from '../lib/inference.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';
+export const copilotArtifactType = z.enum([
+    'study-guide',
+    'worksheet',
+    'flashcards',
+    'notes',
+]);
+export const copilotContextSchema = z.object({
+    workspaceId: z.string().min(1),
+    artifactId: z.string().min(1),
+    artifactType: copilotArtifactType,
+    documentContent: z.string().min(1),
+    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({
+    start: z.number().int().min(0),
+    end: z.number().int().min(0),
+    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) {
+    const fencedMatch = content.match(/```json\s*([\s\S]*?)```/i);
+    if (fencedMatch?.[1]) {
+        try {
+            return JSON.parse(fencedMatch[1]);
+        }
+        catch {
+            // fall through
+        }
+    }
+    const objectMatch = content.match(/\{[\s\S]*\}/);
+    if (objectMatch?.[0]) {
+        try {
+            return JSON.parse(objectMatch[0]);
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+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;
+}
+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 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": [{ "start": 0, "end": 10, "label": "optional" }],',
+        '  "flashcards": [{ "front": "question", "back": "answer" }]',
+        '}',
+        'Include only relevant keys for the task.',
+        '',
+        `MODE: ${params.mode}`,
+        `ARTIFACT_TYPE: ${params.context.artifactType}`,
+    ].join('\n');
+    const contextPrompt = [
+        'DOCUMENT:',
+        documentSnippet,
+        '',
+        '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 inference(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);
+        await PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:thinking', {
+            status: 'started',
+        });
+        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 highlights = z.array(highlightInstructionSchema).safeParse(model.parsed?.highlights);
+        const safeHighlights = highlights.success
+            ? highlights.data.filter((item) => item.start < item.end &&
+                item.end <= Math.max(input.context.documentContent.length, 0))
+            : [];
+        await PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:response', {
+            status: 'completed',
+        });
+        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);
+        await PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:thinking', {
+            status: 'started',
+        });
+        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 PusherService.emitTaskComplete(input.context.workspaceId, 'copilot:response', {
+            status: 'completed',
+        });
+        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 for the provided section.';
+        const history = await this.loadHistory(input.conversationId);
+        const model = await callCopilotModel({
+            mode: 'suggestHighlights',
+            context: input.context,
+            message: instruction,
+            history,
+        });
+        const parsedHighlights = z
+            .array(highlightInstructionSchema)
+            .safeParse(model.parsed?.highlights);
+        const safeHighlights = parsedHighlights.success
+            ? parsedHighlights.data.filter((item) => item.start < item.end &&
+                item.end <= Math.max(input.context.documentContent.length, 0))
+            : [];
+        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 artifact = await this.db.artifact.create({
+            data: {
+                workspaceId: input.context.workspaceId,
+                type: ArtifactType.FLASHCARD_SET,
+                title: `Copilot Flashcards - ${new Date().toLocaleString()}`,
+                createdById: userId,
+                generating: false,
+                flashcards: {
+                    create: cards.map((card, index) => ({
+                        front: sanitizeString(card.front, 200),
+                        back: sanitizeString(card.back, 500),
+                        order: index,
+                        tags: ['copilot-generated'],
+                    })),
+                },
+            },
+            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/flashcard-progress.service.d.ts

@@ -1,4 +1,5 @@
 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
@@ -9,8 +10,7 @@ export interface SM2Result {
     repetitions: number;
     nextReviewAt: Date;
 }
-export declare class FlashcardProgressService {
-    private db;
+export declare class FlashcardProgressService extends BaseService {
     constructor(db: PrismaClient);
     /**
      * Calculate next review using SM-2 algorithm with smart scheduling

package/dist/services/flashcard-progress.service.js

@@ -1,8 +1,9 @@
 import { Prisma } from '@prisma/client';
 import { NotFoundError } from '../lib/errors.js';
-export class FlashcardProgressService {
+import { BaseService } from './base.service.js';
+export class FlashcardProgressService extends BaseService {
     constructor(db) {
-        this.db = db;
+        super(db);
     }
     /**
      * Calculate next review using SM-2 algorithm with smart scheduling