@goscribe/server 1.3.3 → 1.5.0

package/src/{lib/notification-service.ts → services/notifications/notification.service.ts}

@@ -1,4 +1,6 @@
-import PusherService from './pusher.js';
+import type { PrismaClient } from '@prisma/client';
+import PusherService from '../../lib/pusher.js';
+import { BaseService } from '../base.service.js';
 
 type NotificationPriority = 'LOW' | 'NORMAL' | 'HIGH';
 
@@ -675,3 +677,102 @@ export async function notifyArtifactFailed(
     priority: 'HIGH',
   });
 }
+
+/**
+ * Inbox-side operations (list, mark read, delete) used by the notifications
+ * router. Creation flows live in the standalone exported functions above and
+ * are called directly by other services.
+ */
+export class NotificationService extends BaseService {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  async list(
+    userId: string,
+    input: {
+      cursor?: string;
+      limit: number;
+      unreadOnly?: boolean;
+      types?: string[];
+    },
+  ) {
+    const { cursor, limit, unreadOnly, types } = input;
+
+    const items = await this.db.notification.findMany({
+      where: {
+        userId,
+        ...(unreadOnly ? { read: false } : {}),
+        ...(types?.length ? { type: { in: types } } : {}),
+      },
+      include: {
+        actor: { select: { id: true, name: true, email: true } },
+        workspace: { select: { id: true, title: true } },
+      },
+      orderBy: [{ createdAt: 'desc' }, { id: 'desc' }],
+      take: limit + 1,
+      ...(cursor ? { cursor: { id: cursor }, skip: 1 } : {}),
+    });
+
+    let nextCursor: string | undefined;
+    if (items.length > limit) {
+      const next = items.pop();
+      nextCursor = next?.id;
+    }
+
+    return { items, nextCursor };
+  }
+
+  async unreadCount(userId: string) {
+    const count = await this.db.notification.count({
+      where: { userId, read: false },
+    });
+    return { count };
+  }
+
+  async markRead(userId: string, id: string) {
+    const now = new Date();
+    await this.db.notification.updateMany({
+      where: { id, userId },
+      data: { read: true, readAt: now },
+    });
+
+    const unreadCount = await this.db.notification.count({
+      where: { userId, read: false },
+    });
+    await PusherService.emitNotificationReadState(userId, { unreadCount });
+
+    return { success: true };
+  }
+
+  async markManyRead(userId: string, ids: string[]) {
+    const now = new Date();
+    await this.db.notification.updateMany({
+      where: { id: { in: ids }, userId },
+      data: { read: true, readAt: now },
+    });
+
+    const unreadCount = await this.db.notification.count({
+      where: { userId, read: false },
+    });
+    await PusherService.emitNotificationReadState(userId, { unreadCount });
+
+    return { success: true };
+  }
+
+  async markAllRead(userId: string) {
+    const now = new Date();
+    await this.db.notification.updateMany({
+      where: { userId, read: false },
+      data: { read: true, readAt: now },
+    });
+
+    await PusherService.emitNotificationReadState(userId, { unreadCount: 0 });
+    return { success: true };
+  }
+
+  async delete(userId: string, id: string) {
+    await this.db.notification.deleteMany({ where: { id, userId } });
+    return { success: true };
+  }
+}

package/src/services/workspace/workspace-analytics.service.ts

@@ -0,0 +1,107 @@
+import type { PrismaClient } from '@prisma/client';
+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: PrismaClient) {
+    super(db);
+  }
+
+  async getStudyAnalytics(userId: string) {
+    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<string>();
+    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: boolean[] = [];
+    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/src/services/workspace/workspace-kb.service.ts

@@ -0,0 +1,273 @@
+import type { PrismaClient } from '@prisma/client';
+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 interface WorkspaceKbMatch {
+  chunkId: string;
+  documentId: string;
+  documentName: string;
+  chunkIndex: number;
+  content: string;
+  score: number;
+}
+
+export class WorkspaceKbService extends BaseService {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  /** Returns the single auto-managed KB for a workspace, creating it if needed. */
+  async ensureWorkspaceKb(workspaceId: string, userId: string, title?: string) {
+    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: string): Promise<string | null> {
+    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: string,
+    userId: string,
+    input: {
+      sourceType: string;
+      sourceId: string;
+      name: string;
+      text: string;
+    },
+  ) {
+    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 as { sourceType?: string; sourceId?: string } | null;
+        return meta?.sourceType === input.sourceType && meta?.sourceId === input.sourceId;
+      });
+
+      let documentId: string;
+      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: string,
+    userId: string,
+    input: Parameters<WorkspaceKbService['indexText']>[2],
+  ) {
+    void this.indexText(workspaceId, userId, input);
+  }
+
+  async search(
+    workspaceId: string,
+    query: string,
+    topK = 5,
+  ): Promise<WorkspaceKbMatch[]> {
+    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<
+      Array<{
+        id: string;
+        documentId: string;
+        chunkIndex: number;
+        content: string;
+        distance: number;
+        documentName: string;
+      }>
+    >(
+      `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: WorkspaceKbMatch[]): string {
+    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: string,
+    query: string,
+    topK = 5,
+  ): Promise<string> {
+    const matches = await this.search(workspaceId, query, topK);
+    return this.formatContext(matches);
+  }
+}
+
+export const workspaceKbService = new WorkspaceKbService(prisma);