@goscribe/server 1.6.0 → 1.7.0

package/dist/src/services/workspace/workspace-analytics.service.js

@@ -0,0 +1,95 @@
+import { BaseService } from '../base.service.js';
+/**
+ * Study analytics: streaks, weekly activity, flashcard mastery, worksheet
+ * accuracy. Behavior-preserving extraction from `workspace.getStudyAnalytics`.
+ */
+export class WorkspaceAnalyticsService extends BaseService {
+    constructor(db) {
+        super(db);
+    }
+    async getStudyAnalytics(userId) {
+        const flashcardProgress = await this.db.flashcardProgress.findMany({
+            where: { userId },
+            select: { lastStudiedAt: true },
+        });
+        const worksheetProgress = await this.db.worksheetQuestionProgress.findMany({
+            where: { userId },
+            select: { updatedAt: true, completedAt: true },
+        });
+        const studyDays = new Set();
+        for (const fp of flashcardProgress) {
+            if (fp.lastStudiedAt) {
+                studyDays.add(fp.lastStudiedAt.toISOString().split('T')[0]);
+            }
+        }
+        for (const wp of worksheetProgress) {
+            if (wp.completedAt) {
+                studyDays.add(wp.completedAt.toISOString().split('T')[0]);
+            }
+            else {
+                studyDays.add(wp.updatedAt.toISOString().split('T')[0]);
+            }
+        }
+        const sortedDays = [...studyDays].sort().reverse();
+        let streak = 0;
+        if (sortedDays.length > 0) {
+            const today = new Date();
+            today.setHours(0, 0, 0, 0);
+            const yesterday = new Date(today);
+            yesterday.setDate(yesterday.getDate() - 1);
+            const todayStr = today.toISOString().split('T')[0];
+            const yesterdayStr = yesterday.toISOString().split('T')[0];
+            if (sortedDays[0] === todayStr || sortedDays[0] === yesterdayStr) {
+                streak = 1;
+                for (let i = 1; i < sortedDays.length; i++) {
+                    const current = new Date(sortedDays[i - 1]);
+                    const prev = new Date(sortedDays[i]);
+                    const diffDays = (current.getTime() - prev.getTime()) / (1000 * 60 * 60 * 24);
+                    if (diffDays === 1) {
+                        streak++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+        }
+        const weeklyActivity = [];
+        const today = new Date();
+        today.setHours(0, 0, 0, 0);
+        for (let i = 6; i >= 0; i--) {
+            const d = new Date(today);
+            d.setDate(d.getDate() - i);
+            const dayStr = d.toISOString().split('T')[0];
+            weeklyActivity.push(studyDays.has(dayStr));
+        }
+        const totalCards = await this.db.flashcardProgress.count({ where: { userId } });
+        const masteredCards = await this.db.flashcardProgress.count({
+            where: { userId, masteryLevel: { gte: 80 } },
+        });
+        const dueCards = await this.db.flashcardProgress.count({
+            where: { userId, nextReviewAt: { lte: new Date() } },
+        });
+        const completedQuestions = await this.db.worksheetQuestionProgress.count({
+            where: { userId, completedAt: { not: null } },
+        });
+        const correctQuestions = await this.db.worksheetQuestionProgress.count({
+            where: { userId, correct: true },
+        });
+        return {
+            streak,
+            totalStudyDays: studyDays.size,
+            weeklyActivity,
+            flashcards: {
+                total: totalCards,
+                mastered: masteredCards,
+                dueForReview: dueCards,
+            },
+            worksheets: {
+                completed: completedQuestions,
+                correct: correctQuestions,
+                accuracy: completedQuestions > 0 ? Math.round((correctQuestions / completedQuestions) * 100) : 0,
+            },
+        };
+    }
+}

package/dist/src/services/workspace/workspace-kb.service.d.ts

@@ -0,0 +1,40 @@
+import type { PrismaClient } from '@prisma/client';
+import { BaseService } from '../base.service.js';
+export interface WorkspaceKbMatch {
+    chunkId: string;
+    documentId: string;
+    documentName: string;
+    chunkIndex: number;
+    content: string;
+    score: number;
+}
+export declare class WorkspaceKbService extends BaseService {
+    constructor(db: PrismaClient);
+    /** Returns the single auto-managed KB for a workspace, creating it if needed. */
+    ensureWorkspaceKb(workspaceId: string, userId: string, title?: string): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        description: string | null;
+        createdById: string | null;
+        status: import("@prisma/client").KnowledgeBaseStatus;
+        meta: import("@prisma/client/runtime/client").JsonValue | null;
+        isCurated: boolean;
+        embeddingModel: string;
+        embeddingDim: number;
+    }>;
+    getWorkspaceKbId(workspaceId: string): Promise<string | null>;
+    indexText(workspaceId: string, userId: string, input: {
+        sourceType: string;
+        sourceId: string;
+        name: string;
+        text: string;
+    }): Promise<void>;
+    /** Fire-and-forget indexing — never blocks the caller. */
+    indexTextAsync(workspaceId: string, userId: string, input: Parameters<WorkspaceKbService['indexText']>[2]): void;
+    search(workspaceId: string, query: string, topK?: number): Promise<WorkspaceKbMatch[]>;
+    formatContext(matches: WorkspaceKbMatch[]): string;
+    retrieveContext(workspaceId: string, query: string, topK?: number): Promise<string>;
+}
+export declare const workspaceKbService: WorkspaceKbService;

package/dist/src/services/workspace/workspace-kb.service.js

@@ -0,0 +1,184 @@
+import { BaseService } from '../base.service.js';
+import { prisma } from '../../lib/prisma.js';
+import { DEFAULT_EMBEDDING_MODEL, embedQuery, embedTexts, toVectorLiteral, } from '../../lib/embeddings.js';
+import { chunkText } from '../../lib/chunking.js';
+import { WORKSPACE_KB_KIND } from '../../lib/workspace-kb.js';
+export class WorkspaceKbService extends BaseService {
+    constructor(db) {
+        super(db);
+    }
+    /** Returns the single auto-managed KB for a workspace, creating it if needed. */
+    async ensureWorkspaceKb(workspaceId, userId, title) {
+        const existingLink = await this.db.workspaceKnowledgeBase.findFirst({
+            where: {
+                workspaceId,
+                knowledgeBase: {
+                    isCurated: false,
+                    meta: {
+                        path: ['kind'],
+                        equals: WORKSPACE_KB_KIND,
+                    },
+                },
+            },
+            include: { knowledgeBase: true },
+        });
+        if (existingLink) {
+            return existingLink.knowledgeBase;
+        }
+        const workspace = await this.db.workspace.findUnique({
+            where: { id: workspaceId },
+            select: { title: true },
+        });
+        const kb = await this.db.knowledgeBase.create({
+            data: {
+                createdById: userId,
+                name: `${title ?? workspace?.title ?? 'Workspace'} Knowledge Base`,
+                description: 'Private knowledge base for this workspace',
+                isCurated: false,
+                embeddingModel: DEFAULT_EMBEDDING_MODEL,
+                embeddingDim: 1536,
+                meta: { kind: WORKSPACE_KB_KIND, workspaceId },
+            },
+        });
+        await this.db.workspaceKnowledgeBase.create({
+            data: {
+                workspaceId,
+                knowledgeBaseId: kb.id,
+                addedById: userId,
+            },
+        });
+        return kb;
+    }
+    async getWorkspaceKbId(workspaceId) {
+        const link = await this.db.workspaceKnowledgeBase.findFirst({
+            where: {
+                workspaceId,
+                knowledgeBase: {
+                    isCurated: false,
+                    meta: { path: ['kind'], equals: WORKSPACE_KB_KIND },
+                },
+            },
+            select: { knowledgeBaseId: true },
+        });
+        return link?.knowledgeBaseId ?? null;
+    }
+    async indexText(workspaceId, userId, input) {
+        const trimmed = input.text.trim();
+        if (!trimmed)
+            return;
+        try {
+            const kb = await this.ensureWorkspaceKb(workspaceId, userId);
+            const docs = await this.db.knowledgeBaseDocument.findMany({
+                where: { knowledgeBaseId: kb.id },
+                select: { id: true, meta: true },
+            });
+            const existing = docs.find((doc) => {
+                const meta = doc.meta;
+                return meta?.sourceType === input.sourceType && meta?.sourceId === input.sourceId;
+            });
+            let documentId;
+            if (existing) {
+                documentId = existing.id;
+                await this.db.knowledgeBaseChunk.deleteMany({ where: { documentId } });
+                await this.db.knowledgeBaseDocument.update({
+                    where: { id: documentId },
+                    data: {
+                        name: input.name,
+                        status: 'PROCESSING',
+                        errorMessage: null,
+                    },
+                });
+            }
+            else {
+                const created = await this.db.knowledgeBaseDocument.create({
+                    data: {
+                        knowledgeBaseId: kb.id,
+                        name: input.name,
+                        mimeType: 'text/plain',
+                        size: Buffer.byteLength(trimmed, 'utf8'),
+                        status: 'PROCESSING',
+                        meta: {
+                            sourceType: input.sourceType,
+                            sourceId: input.sourceId,
+                        },
+                    },
+                });
+                documentId = created.id;
+            }
+            await this.db.knowledgeBase.update({
+                where: { id: kb.id },
+                data: { status: 'INDEXING' },
+            });
+            const chunks = chunkText(trimmed, { targetTokens: 500, overlapTokens: 60 });
+            if (chunks.length === 0)
+                return;
+            const embeddings = await embedTexts(chunks.map((c) => c.content), { model: kb.embeddingModel });
+            for (let i = 0; i < chunks.length; i += 1) {
+                const chunk = chunks[i];
+                const vec = toVectorLiteral(embeddings[i] ?? []);
+                await this.db.$executeRawUnsafe(`INSERT INTO "KnowledgeBaseChunk"
+            ("id", "documentId", "knowledgeBaseId", "chunkIndex",
+             "pageNumber", "content", "tokenCount", "embedding", "createdAt")
+           VALUES (
+             gen_random_uuid()::text,
+             $1, $2, $3, $4, $5, $6, $7::vector, NOW()
+           )`, documentId, kb.id, chunk.index, null, chunk.content, chunk.approxTokens, vec);
+            }
+            await this.db.knowledgeBaseDocument.update({
+                where: { id: documentId },
+                data: { status: 'READY', numChunks: chunks.length },
+            });
+            await this.db.knowledgeBase.update({
+                where: { id: kb.id },
+                data: { status: 'READY' },
+            });
+        }
+        catch (err) {
+            this.logger.error(`Failed to index ${input.sourceType}:${input.sourceId} into workspace KB`, err);
+        }
+    }
+    /** Fire-and-forget indexing — never blocks the caller. */
+    indexTextAsync(workspaceId, userId, input) {
+        void this.indexText(workspaceId, userId, input);
+    }
+    async search(workspaceId, query, topK = 5) {
+        const kbId = await this.getWorkspaceKbId(workspaceId);
+        if (!kbId)
+            return [];
+        const kb = await this.db.knowledgeBase.findUnique({ where: { id: kbId } });
+        if (!kb)
+            return [];
+        const k = Math.min(Math.max(topK, 1), 20);
+        const queryVec = await embedQuery(query, { model: kb.embeddingModel });
+        const vecLiteral = toVectorLiteral(queryVec);
+        const rows = await this.db.$queryRawUnsafe(`SELECT c."id", c."documentId", c."chunkIndex", c."content",
+              (c."embedding" <=> $1::vector) AS "distance",
+              d."name" AS "documentName"
+         FROM "KnowledgeBaseChunk" c
+         JOIN "KnowledgeBaseDocument" d ON d."id" = c."documentId"
+        WHERE c."knowledgeBaseId" = $2
+          AND c."embedding" IS NOT NULL
+        ORDER BY c."embedding" <=> $1::vector
+        LIMIT ${k}`, vecLiteral, kbId);
+        return rows.map((r) => ({
+            chunkId: r.id,
+            documentId: r.documentId,
+            documentName: r.documentName,
+            chunkIndex: r.chunkIndex,
+            content: r.content,
+            score: 1 - Number(r.distance),
+        }));
+    }
+    formatContext(matches) {
+        if (matches.length === 0)
+            return '';
+        return matches
+            .map((m, i) => `[${i + 1}] (${m.documentName}, chunk ${m.chunkIndex})\n${m.content}`)
+            .join('\n\n---\n\n');
+    }
+    async retrieveContext(workspaceId, query, topK = 5) {
+        const matches = await this.search(workspaceId, query, topK);
+        return this.formatContext(matches);
+    }
+}
+export const workspaceKbService = new WorkspaceKbService(prisma);

package/dist/src/services/workspace/workspace.service.d.ts

@@ -0,0 +1,263 @@
+import type { PrismaClient } from '@prisma/client';
+import { BaseService } from '../base.service.js';
+export declare class WorkspaceService extends BaseService {
+    constructor(db: PrismaClient);
+    list(userId: string, parentId: string | null): Promise<{
+        workspaces: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            ownerId: string;
+            title: string;
+            description: string | null;
+            icon: string;
+            color: string;
+            markerColor: string | null;
+            folderId: string | null;
+            fileBeingAnalyzed: boolean;
+            analysisProgress: import("@prisma/client/runtime/client").JsonValue | null;
+            needsAnalysis: boolean;
+        }[];
+        folders: {
+            id: string;
+            name: string;
+            createdAt: Date;
+            updatedAt: Date;
+            ownerId: string;
+            color: string;
+            markerColor: string | null;
+            parentId: string | null;
+        }[];
+    }>;
+    getTree(userId: string): Promise<{
+        folders: {
+            id: string;
+            name: string;
+            updatedAt: Date;
+            color: string;
+            markerColor: string | null;
+            parentId: string | null;
+        }[];
+        workspaces: {
+            id: string;
+            updatedAt: Date;
+            uploads: {
+                id: string;
+                name: string;
+                createdAt: Date;
+                mimeType: string;
+            }[];
+            title: string;
+            icon: string;
+            color: string;
+            markerColor: string | null;
+            folderId: string | null;
+        }[];
+    }>;
+    create(userId: string, input: {
+        name: string;
+        description?: string;
+        parentId?: string;
+        markerColor?: string | null;
+    }): Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        ownerId: string;
+        title: string;
+        description: string | null;
+        icon: string;
+        color: string;
+        markerColor: string | null;
+        folderId: string | null;
+        fileBeingAnalyzed: boolean;
+        analysisProgress: import("@prisma/client/runtime/client").JsonValue | null;
+        needsAnalysis: boolean;
+    }>;
+    createFolder(userId: string, input: {
+        name: string;
+        color?: string;
+        parentId?: string;
+    }): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        ownerId: string;
+        color: string;
+        markerColor: string | null;
+        parentId: string | null;
+    }>;
+    updateFolder(userId: string, input: {
+        id: string;
+        name?: string;
+        markerColor?: string | null;
+    }): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        ownerId: string;
+        color: string;
+        markerColor: string | null;
+        parentId: string | null;
+    }>;
+    deleteFolder(userId: string, id: string): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        ownerId: string;
+        color: string;
+        markerColor: string | null;
+        parentId: string | null;
+    }>;
+    get(userId: string, id: string): Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        uploads: {
+            id: string;
+            name: string;
+            createdAt: Date;
+            size: number;
+            objectKey: string | null;
+            mimeType: string;
+        }[];
+        ownerId: string;
+        title: string;
+        description: string | null;
+        icon: string;
+        color: string;
+        markerColor: string | null;
+        folderId: string | null;
+        fileBeingAnalyzed: boolean;
+        analysisProgress: import("@prisma/client/runtime/client").JsonValue;
+        needsAnalysis: boolean;
+        folder: {
+            id: string;
+            name: string;
+            color: string;
+        } | null;
+    }>;
+    getAccountSummary(userId: string): Promise<import("../billing/usage.service.js").AccountSummary>;
+    getStats(userId: string): Promise<import("../billing/usage.service.js").AccountStats>;
+    update(userId: string, input: {
+        id: string;
+        name?: string;
+        description?: string;
+        markerColor?: string | null;
+        icon?: string;
+    }): Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        ownerId: string;
+        title: string;
+        description: string | null;
+        icon: string;
+        color: string;
+        markerColor: string | null;
+        folderId: string | null;
+        fileBeingAnalyzed: boolean;
+        analysisProgress: import("@prisma/client/runtime/client").JsonValue | null;
+        needsAnalysis: boolean;
+    }>;
+    delete(userId: string, id: string): Promise<boolean>;
+    getFolderInformation(userId: string, id: string): Promise<{
+        folder: {
+            id: string;
+            name: string;
+            createdAt: Date;
+            updatedAt: Date;
+            ownerId: string;
+            color: string;
+            markerColor: string | null;
+            parentId: string | null;
+        };
+        parents: {
+            id: string;
+            name: string;
+            createdAt: Date;
+            updatedAt: Date;
+            ownerId: string;
+            color: string;
+            markerColor: string | null;
+            parentId: string | null;
+        }[];
+    }>;
+    getSharedWith(userId: string, id: string): Promise<{
+        shared: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            ownerId: string;
+            title: string;
+            description: string | null;
+            icon: string;
+            color: string;
+            markerColor: string | null;
+            folderId: string | null;
+            fileBeingAnalyzed: boolean;
+            analysisProgress: import("@prisma/client/runtime/client").JsonValue | null;
+            needsAnalysis: boolean;
+        }[];
+        invitations: ({
+            workspace: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                ownerId: string;
+                title: string;
+                description: string | null;
+                icon: string;
+                color: string;
+                markerColor: string | null;
+                folderId: string | null;
+                fileBeingAnalyzed: boolean;
+                analysisProgress: import("@prisma/client/runtime/client").JsonValue | null;
+                needsAnalysis: boolean;
+            };
+        } & {
+            id: string;
+            email: string;
+            createdAt: Date;
+            updatedAt: Date;
+            role: string;
+            token: string;
+            workspaceId: string;
+            invitedById: string;
+            acceptedAt: Date | null;
+            expiresAt: Date;
+        })[];
+    }>;
+    uploadFiles(userId: string, input: {
+        id: string;
+        files: Array<{
+            filename: string;
+            contentType: string;
+            size: number;
+        }>;
+    }): Promise<{
+        fileId: string;
+        uploadUrl: string;
+    }[]>;
+    deleteFiles(userId: string, input: {
+        fileId: string[];
+        id: string;
+    }): Promise<boolean>;
+    getFileUploadUrl(userId: string, input: {
+        workspaceId: string;
+        filename: string;
+        contentType: string;
+        size: number;
+    }): Promise<{
+        fileId: string;
+        uploadUrl: string;
+    }>;
+    search(userId: string, input: {
+        query: string;
+        color?: string;
+        limit: number;
+    }): Promise<any[]>;
+}