@goscribe/server 1.3.3 → 1.5.0

package/dist/services/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/services/workspace-progress.service.d.ts

@@ -0,0 +1,27 @@
+import type { PrismaClient } from '@prisma/client';
+export type StepStatus = 'pending' | 'in_progress' | 'completed' | 'skipped' | 'error';
+export declare const PIPELINE_STEPS: readonly ["fileUpload", "fileAnalysis", "studyGuide", "flashcards"];
+export declare const PROGRESS_FILENAME_MAX_CHARS = 20;
+export declare function updateAnalysisProgress(db: PrismaClient, workspaceId: string, progress: any): Promise<void>;
+export declare function truncateProgressFilename(value: string, maxChars?: number): string;
+export declare function buildCombinedFilenameLabel(fileNames: string[]): string;
+export declare function buildProgressSteps(currentStep: typeof PIPELINE_STEPS[number], currentStatus: StepStatus, config: {
+    generateStudyGuide: boolean;
+    generateFlashcards: boolean;
+}, overrides?: Partial<Record<typeof PIPELINE_STEPS[number], StepStatus>>): Record<string, {
+    order: number;
+    status: StepStatus;
+}>;
+export declare function buildProgress(status: string, filename: string, fileType: string, currentStep: typeof PIPELINE_STEPS[number], currentStepStatus: StepStatus, config: {
+    generateStudyGuide: boolean;
+    generateFlashcards: boolean;
+}, extra?: Record<string, any>): {
+    status: string;
+    filename: string;
+    fileType: string;
+    startedAt: string;
+    steps: Record<string, {
+        order: number;
+        status: StepStatus;
+    }>;
+};

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

@@ -0,0 +1,56 @@
+import PusherService from '../lib/pusher.js';
+export const PIPELINE_STEPS = ['fileUpload', 'fileAnalysis', 'studyGuide', 'flashcards'];
+export const PROGRESS_FILENAME_MAX_CHARS = 20;
+export async function updateAnalysisProgress(db, workspaceId, progress) {
+    await db.workspace.update({
+        where: { id: workspaceId },
+        data: { analysisProgress: progress },
+    });
+    await PusherService.emitAnalysisProgress(workspaceId, progress);
+}
+export function truncateProgressFilename(value, maxChars = PROGRESS_FILENAME_MAX_CHARS) {
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+export function buildCombinedFilenameLabel(fileNames) {
+    return truncateProgressFilename(fileNames.join(', '));
+}
+export function buildProgressSteps(currentStep, currentStatus, config, overrides) {
+    const stepIndex = PIPELINE_STEPS.indexOf(currentStep);
+    const steps = {};
+    for (let i = 0; i < PIPELINE_STEPS.length; i++) {
+        const step = PIPELINE_STEPS[i];
+        let status;
+        if (overrides?.[step]) {
+            status = overrides[step];
+        }
+        else if (i < stepIndex) {
+            status = 'completed';
+        }
+        else if (i === stepIndex) {
+            status = currentStatus;
+        }
+        else if (step === 'studyGuide' && !config.generateStudyGuide) {
+            status = 'skipped';
+        }
+        else if (step === 'flashcards' && !config.generateFlashcards) {
+            status = 'skipped';
+        }
+        else {
+            status = 'pending';
+        }
+        steps[step] = { order: i + 1, status };
+    }
+    return steps;
+}
+export function buildProgress(status, filename, fileType, currentStep, currentStepStatus, config, extra) {
+    return {
+        status,
+        filename,
+        fileType,
+        startedAt: new Date().toISOString(),
+        steps: buildProgressSteps(currentStep, currentStepStatus, config, extra),
+        ...extra,
+    };
+}

package/dist/services/workspace-progress.service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/workspace-progress.service.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest';
+import { buildCombinedFilenameLabel, buildProgress, buildProgressSteps, truncateProgressFilename, } from './workspace-progress.service.js';
+describe('truncateProgressFilename', () => {
+    it('returns value unchanged when under max', () => {
+        expect(truncateProgressFilename('hello.pdf')).toBe('hello.pdf');
+    });
+    it('truncates long values and appends ellipsis', () => {
+        const result = truncateProgressFilename('this-is-a-very-long-filename.pdf', 10);
+        expect(result).toBe('this-is...');
+        expect(result.length).toBe(10);
+    });
+});
+describe('buildCombinedFilenameLabel', () => {
+    it('joins filenames and truncates', () => {
+        expect(buildCombinedFilenameLabel(['a.pdf', 'b.pdf', 'c.pdf'])).toBe('a.pdf, b.pdf, c.pdf');
+    });
+});
+describe('buildProgressSteps', () => {
+    it('marks completed, current, and future correctly', () => {
+        const steps = buildProgressSteps('studyGuide', 'in_progress', {
+            generateStudyGuide: true,
+            generateFlashcards: true,
+        });
+        expect(steps.fileUpload.status).toBe('completed');
+        expect(steps.fileAnalysis.status).toBe('completed');
+        expect(steps.studyGuide.status).toBe('in_progress');
+        expect(steps.flashcards.status).toBe('pending');
+    });
+    it('respects generateStudyGuide and generateFlashcards flags', () => {
+        const steps = buildProgressSteps('fileUpload', 'in_progress', {
+            generateStudyGuide: false,
+            generateFlashcards: false,
+        });
+        expect(steps.studyGuide.status).toBe('skipped');
+        expect(steps.flashcards.status).toBe('skipped');
+    });
+});
+describe('buildProgress', () => {
+    it('returns serialized payload including steps', () => {
+        const payload = buildProgress('analyzing', 'doc.pdf', 'pdf', 'fileAnalysis', 'in_progress', {
+            generateStudyGuide: true,
+            generateFlashcards: true,
+        });
+        expect(payload.status).toBe('analyzing');
+        expect(payload.filename).toBe('doc.pdf');
+        expect(payload.fileType).toBe('pdf');
+        expect(payload.steps.fileAnalysis.status).toBe('in_progress');
+    });
+});

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

@@ -0,0 +1,307 @@
+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;
+            title: string;
+            description: string | null;
+            ownerId: string;
+            color: string;
+            markerColor: string | null;
+            icon: string;
+            folderId: string | null;
+            fileBeingAnalyzed: boolean;
+            analysisProgress: import("@prisma/client/runtime/library").JsonValue | null;
+            needsAnalysis: boolean;
+        }[];
+        folders: {
+            name: string;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            ownerId: string;
+            parentId: string | null;
+            color: string;
+            markerColor: string | null;
+        }[];
+    }>;
+    getTree(userId: string): Promise<{
+        folders: {
+            name: string;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            ownerId: string;
+            parentId: string | null;
+            color: string;
+            markerColor: string | null;
+        }[];
+        workspaces: ({
+            uploads: {
+                name: string;
+                id: string;
+                createdAt: Date;
+                mimeType: string;
+            }[];
+        } & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            title: string;
+            description: string | null;
+            ownerId: string;
+            color: string;
+            markerColor: string | null;
+            icon: string;
+            folderId: string | null;
+            fileBeingAnalyzed: boolean;
+            analysisProgress: import("@prisma/client/runtime/library").JsonValue | null;
+            needsAnalysis: boolean;
+        })[];
+    }>;
+    create(userId: string, input: {
+        name: string;
+        description?: string;
+        parentId?: string;
+        markerColor?: string | null;
+    }): Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        description: string | null;
+        ownerId: string;
+        color: string;
+        markerColor: string | null;
+        icon: string;
+        folderId: string | null;
+        fileBeingAnalyzed: boolean;
+        analysisProgress: import("@prisma/client/runtime/library").JsonValue | null;
+        needsAnalysis: boolean;
+    }>;
+    createFolder(userId: string, input: {
+        name: string;
+        color?: string;
+        parentId?: string;
+    }): Promise<{
+        name: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        ownerId: string;
+        parentId: string | null;
+        color: string;
+        markerColor: string | null;
+    }>;
+    updateFolder(userId: string, input: {
+        id: string;
+        name?: string;
+        markerColor?: string | null;
+    }): Promise<{
+        name: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        ownerId: string;
+        parentId: string | null;
+        color: string;
+        markerColor: string | null;
+    }>;
+    deleteFolder(userId: string, id: string): Promise<{
+        name: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        ownerId: string;
+        parentId: string | null;
+        color: string;
+        markerColor: string | null;
+    }>;
+    get(userId: string, id: string): Promise<{
+        folder: {
+            name: string;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            ownerId: string;
+            parentId: string | null;
+            color: string;
+            markerColor: string | null;
+        } | null;
+        artifacts: {
+            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: import("@prisma/client/runtime/library").JsonValue | null;
+            worksheetConfig: import("@prisma/client/runtime/library").JsonValue | null;
+            imageObjectKey: string | null;
+        }[];
+        uploads: {
+            meta: import("@prisma/client/runtime/library").JsonValue | null;
+            name: string;
+            id: string;
+            createdAt: Date;
+            workspaceId: string | null;
+            userId: string | null;
+            mimeType: string;
+            size: number;
+            bucket: string | null;
+            objectKey: string | null;
+            url: string | null;
+            checksum: string | null;
+            aiTranscription: import("@prisma/client/runtime/library").JsonValue | null;
+        }[];
+    } & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        description: string | null;
+        ownerId: string;
+        color: string;
+        markerColor: string | null;
+        icon: string;
+        folderId: string | null;
+        fileBeingAnalyzed: boolean;
+        analysisProgress: import("@prisma/client/runtime/library").JsonValue | null;
+        needsAnalysis: boolean;
+    }>;
+    getStats(userId: string): Promise<{
+        workspaces: number;
+        folders: number;
+        lastUpdated: Date | undefined;
+        spaceUsed: number;
+        spaceTotal: number;
+    }>;
+    update(userId: string, input: {
+        id: string;
+        name?: string;
+        description?: string;
+        markerColor?: string | null;
+        icon?: string;
+    }): Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        description: string | null;
+        ownerId: string;
+        color: string;
+        markerColor: string | null;
+        icon: string;
+        folderId: string | null;
+        fileBeingAnalyzed: boolean;
+        analysisProgress: import("@prisma/client/runtime/library").JsonValue | null;
+        needsAnalysis: boolean;
+    }>;
+    delete(userId: string, id: string): Promise<boolean>;
+    getFolderInformation(userId: string, id: string): Promise<{
+        folder: {
+            name: string;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            ownerId: string;
+            parentId: string | null;
+            color: string;
+            markerColor: string | null;
+        };
+        parents: {
+            name: string;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            ownerId: string;
+            parentId: string | null;
+            color: string;
+            markerColor: string | null;
+        }[];
+    }>;
+    getSharedWith(userId: string, id: string): Promise<{
+        shared: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            title: string;
+            description: string | null;
+            ownerId: string;
+            color: string;
+            markerColor: string | null;
+            icon: string;
+            folderId: string | null;
+            fileBeingAnalyzed: boolean;
+            analysisProgress: import("@prisma/client/runtime/library").JsonValue | null;
+            needsAnalysis: boolean;
+        }[];
+        invitations: ({
+            workspace: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                title: string;
+                description: string | null;
+                ownerId: string;
+                color: string;
+                markerColor: string | null;
+                icon: string;
+                folderId: string | null;
+                fileBeingAnalyzed: boolean;
+                analysisProgress: import("@prisma/client/runtime/library").JsonValue | null;
+                needsAnalysis: boolean;
+            };
+        } & {
+            id: string;
+            email: string;
+            createdAt: Date;
+            updatedAt: Date;
+            workspaceId: string;
+            role: string;
+            token: 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[]>;
+}