@goscribe/server 1.0.7 → 1.0.9

package/src/routers/chat.ts

@@ -0,0 +1,275 @@
+import { TRPCError } from "@trpc/server";
+import { authedProcedure, router } from "../trpc.js";
+import z from "zod";
+import PusherService from "../lib/pusher.js";
+
+export const chat = router({
+    getChannels: authedProcedure
+        .input(z.object({ workspaceId: z.string() }))
+        .query(async ({ input, ctx }) => {
+            const channels = await ctx.db.channel.findMany({
+                where: { workspaceId: input.workspaceId },
+                include: { chats: {
+                    include: {
+                        user: {
+                            select: {
+                                id: true,
+                                name: true,
+                                image: true,
+                            }
+                        }
+                    }
+                } },
+            });
+            if (!channels) {
+                const defaultChannel = await ctx.db.channel.create({
+                    data: { workspaceId: input.workspaceId, name: "General" },
+                });
+                return [defaultChannel];
+            }
+            return channels;
+        }),
+    getChannel: authedProcedure
+        .input(z.object({ workspaceId: z.string().optional(), channelId: z.string().optional() }))
+        .query(async ({ input, ctx }) => {
+            if (!input.channelId && input.workspaceId) {
+                const defaultChannel = await ctx.db.channel.create({
+                    data: { workspaceId: input.workspaceId, name: "General" },
+                    include: { chats: {
+                        include: {
+                            user: {
+                                select: {
+                                    id: true,
+                                    name: true,
+                                    image: true,
+                                }
+                            }
+                        }
+                    } },
+                });
+
+                await PusherService.emitTaskComplete(input.workspaceId, "new_channel", {
+                    channelId: defaultChannel.id,
+                    workspaceId: input.workspaceId,
+                    name: "General",
+                    createdAt: defaultChannel.createdAt,
+                });
+
+                return defaultChannel;
+            }
+            const channel = await ctx.db.channel.findUnique({
+                where: { id: input.channelId },
+                include: { chats: {
+                    include: {
+                        user: {
+                            select: {
+                                id: true,
+                                name: true,
+                                image: true,
+                            }
+                        }
+                    }
+                } },
+            });
+
+            if (!channel) {
+                throw new TRPCError({ code: "NOT_FOUND", message: "Channel not found" });
+            }
+
+            return channel;
+        }),
+    removeChannel: authedProcedure
+        .input(z.object({ workspaceId: z.string(), channelId: z.string() }))
+        .mutation(async ({ input, ctx }) => {
+            await ctx.db.channel.delete({ where: { id: input.channelId } });
+            await PusherService.emitTaskComplete(input.workspaceId, "remove_channel", {
+                channelId: input.channelId,
+                deletedAt: new Date().toISOString(),
+            });
+            return { success: true };
+        }),
+    editChannel: authedProcedure
+        .input(z.object({ workspaceId: z.string(), channelId: z.string(), name: z.string() }))
+        .mutation(async ({ input, ctx }) => {
+            const channel = await ctx.db.channel.update({
+                where: { id: input.channelId },
+                data: { name: input.name },
+                include: {
+                    chats: {
+                        include: {
+                            user: {
+                                select: {
+                                    id: true,
+                                    name: true,
+                                    image: true,
+                                }
+                            },
+                        }
+                    }
+                }
+            });
+            await PusherService.emitTaskComplete(input.workspaceId, "edit_channel", {
+                channelId: input.channelId,
+                workspaceId: input.workspaceId,
+                name: input.name,
+            });
+            return channel;
+        }),
+    createChannel: authedProcedure
+        .input(z.object({ workspaceId: z.string(), name: z.string() }))
+        .mutation(async ({ input, ctx }) => {
+            const channel = await ctx.db.channel.create({
+                data: { workspaceId: input.workspaceId, name: input.name },
+                include: {
+                    chats: {
+                        include: {
+                            user: {
+                                select: {
+                                    id: true,
+                                    name: true,
+                                    image: true,
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            // Notify via Pusher
+            await PusherService.emitTaskComplete(input.workspaceId, "new_channel", {
+                channelId: channel.id,
+                workspaceId: input.workspaceId,
+                name: input.name,
+                createdAt: channel.createdAt,
+            });
+            return channel;
+        }),
+    postMessage: authedProcedure
+        .input(z.object({ channelId: z.string(), message: z.string() }))
+        .mutation(async ({ input, ctx }) => {
+            const channel = await ctx.db.channel.findUnique({
+                where: { id: input.channelId },
+                include: {
+                    chats: {
+                        include: {
+                            user: {
+                                select: {
+                                    id: true,
+                                    name: true,
+                                    image: true,
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            if (!channel) {
+                throw new TRPCError({ code: "NOT_FOUND", message: "Channel not found" });
+            }
+            const chat = await ctx.db.chat.create({
+                data: {
+                    channelId: input.channelId,
+                    userId: ctx.session.user.id,
+                    message: input.message,
+                },
+                include: {
+                    user: {
+                        select: {
+                            id: true,
+                            name: true,
+                            image: true,
+                        }
+                    }
+                }
+            });
+            // Notify via Pusher
+            await PusherService.emitChannelEvent(input.channelId, "new_message", chat);
+            return chat;
+        }),
+    editMessage: authedProcedure
+        .input(z.object({ chatId: z.string(), message: z.string() }))
+        .mutation(async ({ input, ctx }) => {   
+            const chat = await ctx.db.chat.findUnique({
+                where: { id: input.chatId },
+                include: {
+                    user: {
+                        select: {
+                            id: true,
+                            name: true,
+                            image: true,
+                        }
+                    }
+                }
+            });
+            if (!chat) {
+                throw new TRPCError({ code: "NOT_FOUND", message: "Chat message not found" });
+            }
+            if (chat.userId !== ctx.session.user.id) {
+                throw new TRPCError({ code: "FORBIDDEN", message: "Not your message to edit" });
+            }
+            const updatedChat = await ctx.db.chat.update({
+                where: { id: input.chatId },
+                data: { message: input.message },
+                include: {
+                    user: {
+                        select: {
+                            id: true,
+                            name: true,
+                            image: true,
+                        }
+                    }
+                }
+            });
+            // Notify via Pusher
+            await PusherService.emitChannelEvent(chat.channelId, "edit_message", {
+                chatId: updatedChat.id,
+                channelId: updatedChat.channelId,
+                userId: updatedChat.userId,
+                message: input.message,
+                updatedAt: updatedChat.updatedAt,
+                user: {
+                    id: ctx.session.user.id,
+                    name: updatedChat.user?.name,
+                    image: updatedChat.user?.image,
+                },
+            });
+            return updatedChat;
+        }),
+    deleteMessage: authedProcedure
+        .input(z.object({ chatId: z.string() }))
+        .mutation(async ({ input, ctx }) => {
+            const chat = await ctx.db.chat.findUnique({
+                where: { id: input.chatId },
+                include: {
+                    user: {
+                        select: {
+                            id: true,
+                            name: true,
+                            image: true,
+                        }
+                    },
+                }
+            });
+            if (!chat) {
+                throw new TRPCError({ code: "NOT_FOUND", message: "Chat message not found" });
+            }
+            if (chat.userId !== ctx.session.user.id) {
+                throw new TRPCError({ code: "FORBIDDEN", message: "Not your message to delete" });
+            }
+            await ctx.db.chat.delete({
+                where: { id: input.chatId },
+            });
+            // Notify via Pusher
+            await PusherService.emitChannelEvent(chat.channelId, "delete_message", {
+                chatId: chat.id,
+                channelId: chat.channelId,
+                userId: chat.userId,
+                deletedAt: new Date().toISOString(),
+                user: {
+                    id: ctx.session.user.id,
+                    name: chat.user?.name,
+                    image: chat.user?.image,
+                },
+            });
+            return { success: true };
+        }),
+});

package/src/routers/flashcards.ts

@@ -1,6 +1,9 @@
 import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
 import { router, authedProcedure } from '../trpc.js';
+import createInferenceService from '../lib/inference.js';
+import { aiSessionService } from '../lib/ai-session.js';
+import PusherService from '../lib/pusher.js';
 // Prisma enum values mapped manually to avoid type import issues in ESM
 const ArtifactType = {
   STUDY_GUIDE: 'STUDY_GUIDE',
@@ -12,7 +15,7 @@ const ArtifactType = {
 
 export const flashcards = router({
   listSets: authedProcedure
-    .input(z.object({ workspaceId: z.string().uuid() }))
+    .input(z.object({ workspaceId: z.string() }))
     .query(async ({ ctx, input }) => {
       const workspace = await ctx.db.workspace.findFirst({
         where: { id: input.workspaceId, ownerId: ctx.session.user.id },
@@ -29,42 +32,22 @@ export const flashcards = router({
         orderBy: { updatedAt: 'desc' },
       });
     }),
-
-  createSet: authedProcedure
-    .input(z.object({ workspaceId: z.string().uuid(), title: z.string().min(1).max(120) }))
-    .mutation(async ({ ctx, input }) => {
-      const workspace = await ctx.db.workspace.findFirst({
-        where: { id: input.workspaceId, ownerId: ctx.session.user.id },
-      });
-      if (!workspace) throw new TRPCError({ code: 'NOT_FOUND' });
-      return ctx.db.artifact.create({
-        data: {
-          workspaceId: input.workspaceId,
-          type: ArtifactType.FLASHCARD_SET,
-          title: input.title,
-          createdById: ctx.session.user.id,
-        },
-      });
-    }),
-
-  getSet: authedProcedure
-    .input(z.object({ setId: z.string().uuid() }))
+  listCards: authedProcedure
+    .input(z.object({ workspaceId: z.string() }))
     .query(async ({ ctx, input }) => {
       const set = await ctx.db.artifact.findFirst({
-        where: {
-          id: input.setId,
-          type: ArtifactType.FLASHCARD_SET,
-          workspace: { ownerId: ctx.session.user.id },
+        where: { workspaceId: input.workspaceId, type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } },
+        include: {
+          flashcards: true,
         },
-        include: { flashcards: true },
+        orderBy: { updatedAt: 'desc' },
       });
       if (!set) throw new TRPCError({ code: 'NOT_FOUND' });
-      return set;
+      return set.flashcards;
     }),
-
   createCard: authedProcedure
     .input(z.object({
-      setId: z.string().uuid(),
+      workspaceId: z.string(),
       front: z.string().min(1),
       back: z.string().min(1),
       tags: z.array(z.string()).optional(),
@@ -72,12 +55,18 @@ export const flashcards = router({
     }))
     .mutation(async ({ ctx, input }) => {
       const set = await ctx.db.artifact.findFirst({
-        where: { id: input.setId, type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } },
+        where: { type: ArtifactType.FLASHCARD_SET, workspace: {
+          id: input.workspaceId,
+        } },
+        include: {
+          flashcards: true,
+        },
+        orderBy: { updatedAt: 'desc' },
       });
       if (!set) throw new TRPCError({ code: 'NOT_FOUND' });
       return ctx.db.flashcard.create({
         data: {
-          artifactId: input.setId,
+          artifactId: set.id,
           front: input.front,
           back: input.back,
           tags: input.tags ?? [],
@@ -88,7 +77,7 @@ export const flashcards = router({
 
   updateCard: authedProcedure
     .input(z.object({
-      cardId: z.string().uuid(),
+      cardId: z.string(),
       front: z.string().optional(),
       back: z.string().optional(),
       tags: z.array(z.string()).optional(),
@@ -111,7 +100,7 @@ export const flashcards = router({
     }),
 
   deleteCard: authedProcedure
-    .input(z.object({ cardId: z.string().uuid() }))
+    .input(z.object({ cardId: z.string() }))
     .mutation(async ({ ctx, input }) => {
       const card = await ctx.db.flashcard.findFirst({
         where: { id: input.cardId, artifact: { workspace: { ownerId: ctx.session.user.id } } },
@@ -130,6 +119,135 @@ export const flashcards = router({
       if (deleted.count === 0) throw new TRPCError({ code: 'NOT_FOUND' });
       return true;
     }),
+
+  // Generate a flashcard set from a user prompt
+  generateFromPrompt: authedProcedure
+    .input(z.object({
+      workspaceId: z.string(),
+      prompt: z.string().min(1),
+      numCards: z.number().int().min(1).max(50).default(10),
+      difficulty: z.enum(['easy', 'medium', 'hard']).default('medium'),
+      title: z.string().optional(),
+      tags: z.array(z.string()).optional(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      // Verify workspace ownership
+      const workspace = await ctx.db.workspace.findFirst({
+        where: { id: input.workspaceId, ownerId: ctx.session.user.id },
+      });
+      if (!workspace) throw new TRPCError({ code: 'NOT_FOUND' });
+
+      // Pusher start
+      await PusherService.emitTaskComplete(input.workspaceId, 'flash_card_load_start', { source: 'prompt' });
+      const flashcardCurrent = await ctx.db.artifact.findFirst({
+        where: {
+          workspaceId: input.workspaceId,
+          type: ArtifactType.FLASHCARD_SET,
+        },
+        select: {
+          flashcards: true,
+        },
+        orderBy: {
+          updatedAt: 'desc',
+        },
+      });
+
+
+      const formattedPreviousCards = flashcardCurrent?.flashcards.map((card) => ({
+        front: card.front,
+        back: card.back,
+      }));
+
+
+      const partialPrompt = `
+      This is the users previous flashcards, avoid repeating any existing cards.
+      Please generate ${input.numCards} new cards,
+      Of a ${input.difficulty} difficulty,
+      Of a ${input.tags?.join(', ')} tag,
+      Of a ${input.title} title.
+      ${formattedPreviousCards?.map((card) => `Front: ${card.front}\nBack: ${card.back}`).join('\n')}
+
+      The user has also left you this prompt: ${input.prompt}
+      `
+      // Init AI session and seed with prompt as instruction
+      const session = await aiSessionService.initSession(input.workspaceId);
+      await aiSessionService.setInstruction(session.id, partialPrompt);
+
+      await aiSessionService.startLLMSession(session.id);
+      
+      const currentCards = flashcardCurrent?.flashcards.length || 0;
+      const newCards = input.numCards - currentCards;
+
+      // Generate
+      await PusherService.emitTaskComplete(input.workspaceId, 'flash_card_info', { status: 'generating', numCards: input.numCards, difficulty: input.difficulty });
+      const content = await aiSessionService.generateFlashcardQuestions(session.id, input.numCards, input.difficulty);
+
+      // Previous cards
+
+      // Create artifact
+      const artifact = await ctx.db.artifact.create({
+        data: {
+          workspaceId: input.workspaceId,
+          type: ArtifactType.FLASHCARD_SET,
+          title: input.title || `Flashcards - ${new Date().toLocaleString()}`,
+          createdById: ctx.session.user.id,
+          flashcards: {
+            create: flashcardCurrent?.flashcards.map((card) => ({
+              front: card.front,
+              back: card.back,
+            })),
+          },
+        },
+      });
+
+      // Parse and create cards
+      let createdCards = 0;
+      try {
+        const flashcardData = JSON.parse(content);
+        for (let i = 0; i < Math.min(flashcardData.length, input.numCards); i++) {
+          const card = flashcardData[i];
+          const front = card.term || card.front || card.question || card.prompt || `Question ${i + 1}`;
+          const back = card.definition || card.back || card.answer || card.solution || `Answer ${i + 1}`;
+          await ctx.db.flashcard.create({
+            data: {
+              artifactId: artifact.id,
+              front,
+              back,
+              order: i,
+              tags: input.tags ?? ['ai-generated', input.difficulty],
+            },
+          });
+          createdCards++;
+        }
+      } catch {
+        // Fallback to text parsing if JSON fails
+        const lines = content.split('\n').filter(line => line.trim());
+        for (let i = 0; i < Math.min(lines.length, input.numCards); i++) {
+          const line = lines[i];
+          if (line.includes(' - ')) {
+            const [front, back] = line.split(' - ');
+            await ctx.db.flashcard.create({
+              data: {
+                artifactId: artifact.id,
+                front: front.trim(),
+                back: back.trim(),
+                order: i,
+                tags: input.tags ?? ['ai-generated', input.difficulty],
+              },
+            });
+            createdCards++;
+          }
+        }
+      }
+
+      // Pusher complete
+      await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
+
+      // Cleanup AI session (best-effort)
+      aiSessionService.deleteSession(session.id);
+
+      return { artifact, createdCards };
+    }),
 });