@goscribe/server 1.3.4 → 1.6.0

package/src/lib/inference.ts

@@ -1,21 +1 @@
-import OpenAI from 'openai';
-
-const openai = new OpenAI({
-    apiKey: process.env.INFERENCE_API_KEY,
-    baseURL: process.env.INFERENCE_BASE_URL,
-});
-
-async function inference(messages: { role: 'system' | 'user' | 'assistant', content: string }[]) {
-    try {
-        const response = await openai.chat.completions.create({
-            model: "command-a-03-2025",
-            messages: messages,
-        });
-        return response;
-    } catch (error) {
-        // Inference error logged at call site
-        throw error;
-    }
-}
-
-export default inference;
+export { complete as default, complete, completeText } from './ai/llm-client.js';

package/src/lib/kb-meta.ts

@@ -0,0 +1,81 @@
+import { CURATED_KB_SEEDS, type CuratedKbSeed } from './curated-kb-seed.js';
+
+export type KbMetaRecord = {
+  slug?: string;
+  category?: string;
+  subject?: string;
+  kind?: string;
+};
+
+const CURATED_BY_NAME = new Map<string, CuratedKbSeed>(
+  CURATED_KB_SEEDS.map((seed) => [seed.name.trim().toLowerCase(), seed]),
+);
+
+function inferSubject(name: string): string | undefined {
+  const lower = name.toLowerCase();
+  if (lower.includes('biology') || /\bbio\b/.test(lower)) return 'biology';
+  if (lower.includes('chemistry') || /\bchem\b/.test(lower)) return 'chemistry';
+  if (lower.includes('physics')) return 'physics';
+  if (lower.includes('calculus')) return 'calculus';
+  if (lower.includes('statistics') || lower.includes('stats')) return 'math';
+  if (lower.includes('math') || lower.includes('algebra') || lower.includes('geometry')) {
+    return 'math';
+  }
+  if (lower.includes('literature') || lower.includes('literary')) return 'literature';
+  if (lower.includes('english') || lower.includes('writing') || lower.includes('rhetoric')) {
+    return 'english';
+  }
+  if (lower.includes('history') || lower.includes('historical')) return 'history';
+  if (lower.includes('psychology') || lower.includes('psych')) return 'psychology';
+  if (lower.includes('economics') || lower.includes('econ')) return 'economics';
+  if (lower.includes('environmental') || lower.includes('ecology')) return 'environmental';
+  if (lower.includes('computer') || lower.includes('programming') || lower.includes('cs ')) {
+    return 'science';
+  }
+  if (lower.includes('government') || lower.includes('politics')) return 'history';
+  return undefined;
+}
+
+function inferCategory(name: string, category?: string): 'AP' | 'IB' | 'General' {
+  if (category === 'AP' || category === 'IB') return category;
+  const lower = name.toLowerCase();
+  if (lower.startsWith('ap ') || lower.includes(' ap ') || lower.includes('advanced placement')) {
+    return 'AP';
+  }
+  if (lower.startsWith('ib ') || lower.includes(' ib ') || lower.includes('baccalaureate')) {
+    return 'IB';
+  }
+  return 'General';
+}
+
+function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 80);
+}
+
+/** Build catalog meta for new KBs so clients can assign icons and banner colors. */
+export function buildKbMetaFromName(name: string, existing?: KbMetaRecord | null): KbMetaRecord {
+  const trimmed = name.trim();
+  const curated = CURATED_BY_NAME.get(trimmed.toLowerCase());
+  if (curated) {
+    return {
+      slug: curated.slug,
+      category: curated.category,
+      subject: curated.subject,
+    };
+  }
+
+  const subject = existing?.subject ?? inferSubject(trimmed);
+  const category = inferCategory(trimmed, existing?.category);
+  const slug = existing?.slug ?? (subject ? `${slugify(trimmed)}-${subject}` : slugify(trimmed));
+
+  return {
+    slug: slug || undefined,
+    category: category === 'General' ? undefined : category,
+    subject,
+    ...(existing?.kind ? { kind: existing.kind } : {}),
+  };
+}

package/src/lib/pdf.ts

@@ -0,0 +1,23 @@
+/**
+ * Thin wrapper around `pdf-parse` that returns plain text + page count.
+ *
+ * pdf-parse is loaded lazily and via a deep import to avoid the package's
+ * top-level "test" code that runs when the module index is loaded directly.
+ */
+export interface ExtractedPdf {
+  text: string;
+  numPages: number;
+}
+
+export async function extractPdfText(buffer: Buffer): Promise<ExtractedPdf> {
+  // Deep import skips pdf-parse's top-level demo block (`if (!module.parent)`).
+  // @ts-ignore - no types ship for the deep file
+  const mod = await import('pdf-parse/lib/pdf-parse.js');
+  const pdfParse: (b: Buffer) => Promise<{ text: string; numpages: number }> =
+    (mod as any).default ?? (mod as any);
+  const data = await pdfParse(buffer);
+  return {
+    text: data.text ?? '',
+    numPages: data.numpages ?? 0,
+  };
+}

package/src/lib/workspace-kb.ts

@@ -0,0 +1,7 @@
+/** Meta.kind value for the private, auto-managed KB attached to each workspace. */
+export const WORKSPACE_KB_KIND = 'workspace';
+
+export function isWorkspaceManagedKb(kb: { meta: unknown }): boolean {
+  if (!kb.meta || typeof kb.meta !== 'object') return false;
+  return (kb.meta as Record<string, unknown>).kind === WORKSPACE_KB_KIND;
+}

package/src/repositories/artifact.repository.ts

@@ -0,0 +1,55 @@
+import type { ArtifactType, Prisma, PrismaClient } from '@prisma/client';
+import { BaseRepository } from './base.repository.js';
+import { workspaceAccessWhere } from './workspace.repository.js';
+
+export class ArtifactRepository extends BaseRepository {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  /**
+   * Fetch an artifact if the user can access the containing workspace
+   * (owner or member).
+   */
+  findByIdAccessible(artifactId: string, userId: string, include?: Prisma.ArtifactInclude) {
+    return this.db.artifact.findFirst({
+      where: {
+        id: artifactId,
+        workspace: workspaceAccessWhere(userId),
+      },
+      include,
+    });
+  }
+
+  findByIdAndTypeAccessible(
+    artifactId: string,
+    type: ArtifactType,
+    userId: string,
+    include?: Prisma.ArtifactInclude,
+  ) {
+    return this.db.artifact.findFirst({
+      where: {
+        id: artifactId,
+        type,
+        workspace: workspaceAccessWhere(userId),
+      },
+      include,
+    });
+  }
+
+  listByWorkspaceAndType(
+    workspaceId: string,
+    type: ArtifactType,
+    userId: string,
+    args?: Omit<Prisma.ArtifactFindManyArgs, 'where'>,
+  ) {
+    return this.db.artifact.findMany({
+      ...args,
+      where: {
+        workspaceId,
+        type,
+        workspace: workspaceAccessWhere(userId),
+      },
+    });
+  }
+}

package/src/repositories/base.repository.ts

@@ -0,0 +1,19 @@
+import type { PrismaClient } from '@prisma/client';
+import { logger } from '../lib/logger.js';
+
+/**
+ * Shared base class for repositories.
+ *
+ * Repositories own data access. They wrap a Prisma client and expose
+ * intent-revealing methods (e.g. `findAccessibleById(workspaceId, userId)`)
+ * so that the shape of `where` clauses doesn't leak into services/routers.
+ */
+export abstract class BaseRepository {
+  protected readonly db: PrismaClient;
+  protected readonly logger: typeof logger;
+
+  constructor(db: PrismaClient) {
+    this.db = db;
+    this.logger = logger;
+  }
+}

package/src/repositories/invitation.repository.ts

@@ -0,0 +1,53 @@
+import type { Prisma, PrismaClient } from '@prisma/client';
+import { BaseRepository } from './base.repository.js';
+
+/**
+ * Data access for `WorkspaceInvitation`. Members router currently performs
+ * invitation CRUD + token validation directly against Prisma — this
+ * repository is the target of that extraction during Phase 4.
+ */
+export class InvitationRepository extends BaseRepository {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  findById(id: string, include?: Prisma.WorkspaceInvitationInclude) {
+    return this.db.workspaceInvitation.findFirst({
+      where: { id },
+      include,
+    });
+  }
+
+  findFirst(args: Prisma.WorkspaceInvitationFindFirstArgs) {
+    return this.db.workspaceInvitation.findFirst(args);
+  }
+
+  listByWorkspace(workspaceId: string, args?: Omit<Prisma.WorkspaceInvitationFindManyArgs, 'where'>) {
+    return this.db.workspaceInvitation.findMany({
+      ...args,
+      where: { workspaceId },
+    });
+  }
+
+  listForUserEmail(email: string, args?: Omit<Prisma.WorkspaceInvitationFindManyArgs, 'where'>) {
+    return this.db.workspaceInvitation.findMany({
+      ...args,
+      where: { email },
+    });
+  }
+
+  create(data: Prisma.WorkspaceInvitationCreateInput) {
+    return this.db.workspaceInvitation.create({ data });
+  }
+
+  update(id: string, data: Prisma.WorkspaceInvitationUpdateInput) {
+    return this.db.workspaceInvitation.update({
+      where: { id },
+      data,
+    });
+  }
+
+  delete(id: string) {
+    return this.db.workspaceInvitation.delete({ where: { id } });
+  }
+}

package/src/repositories/notification.repository.ts

@@ -0,0 +1,53 @@
+import type { Prisma, PrismaClient } from '@prisma/client';
+import { BaseRepository } from './base.repository.js';
+
+/**
+ * Thin data-access wrapper around `Notification`. `NotificationService`
+ * currently calls `ctx.db.notification.*` directly; Phase 4 will migrate it
+ * to use this repository so services don't need Prisma-specific types at
+ * their API boundary.
+ */
+export class NotificationRepository extends BaseRepository {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  findFirst(args: Prisma.NotificationFindFirstArgs) {
+    return this.db.notification.findFirst(args);
+  }
+
+  listByUser(userId: string, args?: Omit<Prisma.NotificationFindManyArgs, 'where'>) {
+    return this.db.notification.findMany({
+      ...args,
+      where: { userId },
+    });
+  }
+
+  count(args: Prisma.NotificationCountArgs) {
+    return this.db.notification.count(args);
+  }
+
+  create(data: Prisma.NotificationCreateInput) {
+    return this.db.notification.create({ data });
+  }
+
+  markRead(id: string, userId: string) {
+    return this.db.notification.updateMany({
+      where: { id, userId },
+      data: { read: true },
+    });
+  }
+
+  markAllRead(userId: string) {
+    return this.db.notification.updateMany({
+      where: { userId, read: false },
+      data: { read: true },
+    });
+  }
+
+  delete(id: string, userId: string) {
+    return this.db.notification.deleteMany({
+      where: { id, userId },
+    });
+  }
+}

package/src/repositories/user.repository.ts

@@ -0,0 +1,44 @@
+import type { Prisma, PrismaClient } from '@prisma/client';
+import { BaseRepository } from './base.repository.js';
+
+export class UserRepository extends BaseRepository {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  findById(id: string, args?: Omit<Prisma.UserFindUniqueArgs, 'where'>) {
+    return this.db.user.findUnique({
+      ...args,
+      where: { id },
+    });
+  }
+
+  findByEmail(email: string, args?: Omit<Prisma.UserFindUniqueArgs, 'where'>) {
+    return this.db.user.findUnique({
+      ...args,
+      where: { email },
+    });
+  }
+
+  create(data: Prisma.UserCreateInput) {
+    return this.db.user.create({ data });
+  }
+
+  update(id: string, data: Prisma.UserUpdateInput) {
+    return this.db.user.update({
+      where: { id },
+      data,
+    });
+  }
+
+  /**
+   * Soft-delete marker: set `deletedAt`. Hard-delete happens in
+   * `scripts/purge-deleted-users.ts`.
+   */
+  softDelete(id: string) {
+    return this.db.user.update({
+      where: { id },
+      data: { deletedAt: new Date() },
+    });
+  }
+}

package/src/repositories/workspace-member.repository.ts

@@ -0,0 +1,38 @@
+import type { Prisma, PrismaClient } from '@prisma/client';
+import { BaseRepository } from './base.repository.js';
+
+export class WorkspaceMemberRepository extends BaseRepository {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  findByWorkspaceAndUser(workspaceId: string, userId: string) {
+    return this.db.workspaceMember.findFirst({
+      where: { workspaceId, userId },
+    });
+  }
+
+  listByWorkspace(workspaceId: string, include?: Prisma.WorkspaceMemberInclude) {
+    return this.db.workspaceMember.findMany({
+      where: { workspaceId },
+      include,
+    });
+  }
+
+  create(data: Prisma.WorkspaceMemberCreateInput) {
+    return this.db.workspaceMember.create({ data });
+  }
+
+  delete(workspaceId: string, userId: string) {
+    return this.db.workspaceMember.deleteMany({
+      where: { workspaceId, userId },
+    });
+  }
+
+  updateRole(workspaceId: string, userId: string, role: string) {
+    return this.db.workspaceMember.updateMany({
+      where: { workspaceId, userId },
+      data: { role },
+    });
+  }
+}

package/src/repositories/workspace.repository.ts

@@ -0,0 +1,89 @@
+import type { Prisma, PrismaClient } from '@prisma/client';
+import { BaseRepository } from './base.repository.js';
+
+/**
+ * Prisma `where` fragment: workspace is accessible to the user if they are
+ * the owner OR a workspace member. Prefer this over ad-hoc `{ ownerId }`
+ * checks to keep collaborative-workspace behavior consistent.
+ *
+ * NOTE: This is the canonical replacement for the former
+ * `lib/workspace-access.ts#workspaceAccessFilter`. Call sites that previously
+ * spread the filter into a larger `where` can still do so.
+ */
+export function workspaceAccessWhere(userId: string): Prisma.WorkspaceWhereInput {
+  return {
+    OR: [
+      { ownerId: userId },
+      { members: { some: { userId } } },
+    ],
+  };
+}
+
+/**
+ * Prisma `where` fragment for owner-only access. Some legacy call sites
+ * (e.g. `workspace.list`, `workspace.create`, some `workspace.getTree`
+ * paths) intentionally use owner-only semantics. Keep a separate helper so
+ * the difference is explicit at the call site.
+ */
+export function workspaceOwnerWhere(userId: string): Prisma.WorkspaceWhereInput {
+  return { ownerId: userId };
+}
+
+export class WorkspaceRepository extends BaseRepository {
+  constructor(db: PrismaClient) {
+    super(db);
+  }
+
+  /**
+   * Fetch a workspace if the user is the owner OR a member.
+   * Preserves the member-inclusive behavior used by most read paths.
+   */
+  findByIdAccessible(workspaceId: string, userId: string) {
+    return this.db.workspace.findFirst({
+      where: {
+        id: workspaceId,
+        ...workspaceAccessWhere(userId),
+      },
+    });
+  }
+
+  /**
+   * Fetch a workspace only if the user owns it. Preserves the owner-only
+   * semantics used today by `workspace.list`, `workspace.create`, and some
+   * management paths.
+   */
+  findByIdOwned(workspaceId: string, userId: string) {
+    return this.db.workspace.findFirst({
+      where: {
+        id: workspaceId,
+        ownerId: userId,
+      },
+    });
+  }
+
+  listAccessible(userId: string, args?: Omit<Prisma.WorkspaceFindManyArgs, 'where'>) {
+    return this.db.workspace.findMany({
+      ...args,
+      where: workspaceAccessWhere(userId),
+    });
+  }
+
+  listOwned(userId: string, args?: Omit<Prisma.WorkspaceFindManyArgs, 'where'>) {
+    return this.db.workspace.findMany({
+      ...args,
+      where: { ownerId: userId },
+    });
+  }
+
+  /**
+   * Escape hatch for services that need to splice the access clause into a
+   * larger query (e.g. `artifact.findFirst({ where: { ..., workspace: ... } })`).
+   */
+  static accessibleWhere(userId: string): Prisma.WorkspaceWhereInput {
+    return workspaceAccessWhere(userId);
+  }
+
+  static ownedWhere(userId: string): Prisma.WorkspaceWhereInput {
+    return workspaceOwnerWhere(userId);
+  }
+}

package/src/routers/_app.ts

@@ -14,6 +14,8 @@ import { admin } from './admin.js';
 import { paymentRouter } from './payment.js';
 import { copilot } from './copilot.js';
 import { notifications } from './notifications.js';
+import { knowledgeBase } from './knowledgeBase.js';
+import { artifactVersions } from './artifactVersions.js';
 
 export const appRouter = router({
   auth,
@@ -28,6 +30,8 @@ export const appRouter = router({
   payment: paymentRouter,
   copilot,
   notifications,
+  knowledgeBase,
+  artifactVersions,
   // Public member endpoints (for invitation acceptance)
   member: router({
     acceptInvite: members.acceptInvite,