@goscribe/server 1.6.0 → 1.7.0

package/dist/src/lib/kb-meta.js

@@ -0,0 +1,77 @@
+import { CURATED_KB_SEEDS } from './curated-kb-seed.js';
+const CURATED_BY_NAME = new Map(CURATED_KB_SEEDS.map((seed) => [seed.name.trim().toLowerCase(), seed]));
+function inferSubject(name) {
+    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, category) {
+    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) {
+    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, existing) {
+    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/dist/src/lib/logger.d.ts

@@ -0,0 +1,62 @@
+export declare enum LogLevel {
+    ERROR = 0,
+    WARN = 1,
+    INFO = 2,
+    DEBUG = 3,
+    TRACE = 4
+}
+export interface LogEntry {
+    timestamp: string;
+    level: string;
+    message: string;
+    context?: string;
+    metadata?: Record<string, any>;
+    error?: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
+}
+export interface LoggerConfig {
+    level: LogLevel;
+    enableConsole: boolean;
+    enableFile: boolean;
+    logDir?: string;
+    maxFileSize?: number;
+    maxFiles?: number;
+    format?: 'json' | 'pretty';
+}
+declare class Logger {
+    private config;
+    private logStream?;
+    constructor(config?: Partial<LoggerConfig>);
+    private setupFileLogging;
+    private shouldLog;
+    private formatLogEntry;
+    private formatLevel;
+    private formatTimestamp;
+    private formatContext;
+    private formatMetadata;
+    private formatValue;
+    private formatError;
+    private log;
+    error(message: string, contextOrError?: string | Error | unknown, metadata?: Record<string, any>, error?: Error): void;
+    warn(message: string, contextOrMeta?: string | Record<string, any>, metadata?: Record<string, any>): void;
+    info(message: string, contextOrMeta?: string | Record<string, any>, metadata?: Record<string, any>): void;
+    debug(message: string, contextOrMeta?: string | Record<string, any>, metadata?: Record<string, any>): void;
+    trace(message: string, context?: string, metadata?: Record<string, any>): void;
+    http(method: string, url: string, statusCode: number, responseTime?: number, context?: string): void;
+    private getHttpStatusIcon;
+    database(operation: string, table: string, duration?: number, context?: string): void;
+    private getDatabaseOperationIcon;
+    auth(action: string, userId?: string, context?: string): void;
+    trpc(procedure: string, input?: any, output?: any, duration?: number, context?: string): void;
+    updateConfig(newConfig: Partial<LoggerConfig>): void;
+    progress(message: string, current: number, total: number, context?: string): void;
+    private createProgressBar;
+    success(message: string, context?: string, metadata?: Record<string, any>): void;
+    failure(message: string, context?: string, metadata?: Record<string, any>, error?: Error): void;
+    close(): void;
+}
+export declare const logger: Logger;
+export { Logger };

package/dist/src/lib/logger.js

@@ -0,0 +1,364 @@
+import { createWriteStream, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+    LogLevel[LogLevel["TRACE"] = 4] = "TRACE";
+})(LogLevel || (LogLevel = {}));
+// Icons and colors for different log levels
+const LOG_STYLES = {
+    [LogLevel.ERROR]: {
+        icon: '❌',
+        color: '\x1b[31m', // Red
+        bgColor: '\x1b[41m', // Red background
+        bold: '\x1b[1m',
+    },
+    [LogLevel.WARN]: {
+        icon: '⚠️ ',
+        color: '\x1b[33m', // Yellow
+        bgColor: '\x1b[43m', // Yellow background
+        bold: '\x1b[1m',
+    },
+    [LogLevel.INFO]: {
+        icon: 'ℹ️ ',
+        color: '\x1b[36m', // Cyan
+        bgColor: '\x1b[46m', // Cyan background
+        bold: '\x1b[1m',
+    },
+    [LogLevel.DEBUG]: {
+        icon: '🐛',
+        color: '\x1b[35m', // Magenta
+        bgColor: '\x1b[45m', // Magenta background
+        bold: '\x1b[1m',
+    },
+    [LogLevel.TRACE]: {
+        icon: '🔍',
+        color: '\x1b[37m', // White
+        bgColor: '\x1b[47m', // White background
+        bold: '\x1b[1m',
+    },
+};
+// Context icons for common services
+const CONTEXT_ICONS = {
+    'SERVER': '🖥️ ',
+    'HTTP': '🌐',
+    'API': '🔌',
+    'AUTH': '🔐',
+    'DATABASE': '🗄️ ',
+    'DB': '🗄️ ',
+    'TRPC': '⚡',
+    'WORKSPACE': '📁',
+    'WORKSHEET': '📝',
+    'FLASHCARD': '🃏',
+    'STUDYGUIDE': '📚',
+    'PODCAST': '🎙️ ',
+    'MEETING': '🤝',
+    'CHAT': '💬',
+    'FILE': '📄',
+    'STORAGE': '💾',
+    'CACHE': '⚡',
+    'MIDDLEWARE': '🔧',
+    'PERFORMANCE': '⚡',
+    'SECURITY': '🛡️ ',
+    'VALIDATION': '✅',
+    'ERROR': '❌',
+    'SUCCESS': '✅',
+    'LOGGER': '📋',
+};
+class Logger {
+    constructor(config = {}) {
+        this.config = {
+            level: LogLevel.INFO,
+            enableConsole: true,
+            enableFile: false,
+            logDir: './logs',
+            maxFileSize: 10 * 1024 * 1024, // 10MB
+            maxFiles: 5,
+            format: 'pretty',
+            ...config,
+        };
+        if (this.config.enableFile) {
+            this.setupFileLogging();
+        }
+    }
+    setupFileLogging() {
+        if (!this.config.logDir)
+            return;
+        // Ensure log directory exists
+        if (!existsSync(this.config.logDir)) {
+            mkdirSync(this.config.logDir, { recursive: true });
+        }
+        const logFile = join(this.config.logDir, `app-${new Date().toISOString().split('T')[0]}.log`);
+        this.logStream = createWriteStream(logFile, { flags: 'a' });
+    }
+    shouldLog(level) {
+        return level <= this.config.level;
+    }
+    formatLogEntry(entry) {
+        if (this.config.format === 'json') {
+            return JSON.stringify(entry) + '\n';
+        }
+        // Pretty format with enhanced styling
+        const timestamp = this.formatTimestamp(entry.timestamp);
+        const level = this.formatLevel(entry.level);
+        const context = entry.context ? this.formatContext(entry.context) : '';
+        const metadata = entry.metadata ? this.formatMetadata(entry.metadata) : '';
+        const error = entry.error ? this.formatError(entry.error) : '';
+        return `${timestamp} ${level} ${context}${entry.message}${metadata}${error}`;
+    }
+    formatLevel(level) {
+        const levelNum = LogLevel[level];
+        const style = LOG_STYLES[levelNum];
+        return `${style.color}${style.bold}${level.padEnd(5)}\x1b[0m`;
+    }
+    formatTimestamp(timestamp) {
+        const date = new Date(timestamp);
+        const time = date.toLocaleTimeString('en-US', {
+            hour12: false,
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+        });
+        return `\x1b[90m${time}\x1b[0m`; // Gray color
+    }
+    formatContext(context) {
+        if (typeof context !== 'string')
+            return '';
+        const icon = CONTEXT_ICONS[context.toUpperCase()] || '📦';
+        return `\x1b[94m${icon}${context}\x1b[0m `; // Blue color
+    }
+    formatMetadata(metadata) {
+        const entries = Object.entries(metadata)
+            .map(([key, value]) => {
+            const formattedValue = this.formatValue(value);
+            return `\x1b[93m${key}\x1b[0m=\x1b[96m${formattedValue}\x1b[0m`;
+        })
+            .join(' \x1b[90m|\x1b[0m ');
+        return entries ? `\n  \x1b[90m└─\x1b[0m \x1b[90m{\x1b[0m ${entries} \x1b[90m}\x1b[0m` : '';
+    }
+    formatValue(value) {
+        if (value === null)
+            return '\x1b[90mnull\x1b[0m';
+        if (value === undefined)
+            return '\x1b[90mundefined\x1b[0m';
+        if (typeof value === 'boolean')
+            return value ? '\x1b[92mtrue\x1b[0m' : '\x1b[91mfalse\x1b[0m';
+        if (typeof value === 'number')
+            return `\x1b[95m${value}\x1b[0m`;
+        if (typeof value === 'string')
+            return `\x1b[96m"${value}"\x1b[0m`;
+        if (typeof value === 'object') {
+            if (Array.isArray(value)) {
+                const items = value.map(item => this.formatValue(item)).join('\x1b[90m, \x1b[0m');
+                return `\x1b[90m[\x1b[0m${items}\x1b[90m]\x1b[0m`;
+            }
+            const objEntries = Object.entries(value)
+                .map(([k, v]) => `\x1b[93m${k}\x1b[0m:\x1b[96m${this.formatValue(v)}\x1b[0m`)
+                .join('\x1b[90m, \x1b[0m');
+            return `\x1b[90m{\x1b[0m${objEntries}\x1b[90m}\x1b[0m`;
+        }
+        return `\x1b[96m${String(value)}\x1b[0m`;
+    }
+    formatError(error) {
+        let errorStr = `\n  \x1b[90m└─\x1b[0m \x1b[31m❌ \x1b[93m${error.name}\x1b[0m: \x1b[91m${error.message}\x1b[0m`;
+        if (error.stack) {
+            const stackLines = error.stack.split('\n').slice(1, 4); // Show first 3 stack lines
+            errorStr += `\n    \x1b[90m└─ Stack:\x1b[0m`;
+            stackLines.forEach((line, index) => {
+                const isLast = index === stackLines.length - 1;
+                const connector = isLast ? '└─' : '├─';
+                errorStr += `\n      \x1b[90m${connector} \x1b[0m\x1b[90m${line.trim()}\x1b[0m`;
+            });
+        }
+        return errorStr;
+    }
+    log(level, message, context, metadata, error) {
+        if (!this.shouldLog(level))
+            return;
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level: LogLevel[level],
+            message,
+            context,
+            metadata,
+            error: error ? {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+            } : undefined,
+        };
+        const formattedLog = this.formatLogEntry(entry);
+        if (this.config.enableConsole) {
+            // Enhanced console output with icons and colors
+            const style = LOG_STYLES[level];
+            const reset = '\x1b[0m';
+            // Create a beautiful log line with proper spacing and colors
+            const logLine = `${style.color}${style.icon} ${formattedLog}${reset}`;
+            console.log(logLine);
+        }
+        if (this.config.enableFile && this.logStream) {
+            this.logStream.write(formattedLog + '\n');
+        }
+    }
+    error(message, contextOrError, metadata, error) {
+        if (contextOrError instanceof Error) {
+            this.log(LogLevel.ERROR, message, undefined, metadata, contextOrError);
+        }
+        else {
+            this.log(LogLevel.ERROR, message, contextOrError, metadata, error);
+        }
+    }
+    warn(message, contextOrMeta, metadata) {
+        if (typeof contextOrMeta === 'object' && contextOrMeta !== null) {
+            this.log(LogLevel.WARN, message, undefined, contextOrMeta);
+        }
+        else {
+            this.log(LogLevel.WARN, message, contextOrMeta, metadata);
+        }
+    }
+    info(message, contextOrMeta, metadata) {
+        if (typeof contextOrMeta === 'object' && contextOrMeta !== null) {
+            this.log(LogLevel.INFO, message, undefined, contextOrMeta);
+        }
+        else {
+            this.log(LogLevel.INFO, message, contextOrMeta, metadata);
+        }
+    }
+    debug(message, contextOrMeta, metadata) {
+        if (typeof contextOrMeta === 'object' && contextOrMeta !== null) {
+            this.log(LogLevel.DEBUG, message, undefined, contextOrMeta);
+        }
+        else {
+            this.log(LogLevel.DEBUG, message, contextOrMeta, metadata);
+        }
+    }
+    trace(message, context, metadata) {
+        this.log(LogLevel.TRACE, message, context, metadata);
+    }
+    // Convenience methods for common use cases
+    http(method, url, statusCode, responseTime, context) {
+        const statusIcon = this.getHttpStatusIcon(statusCode);
+        const responseTimeStr = responseTime ? `${responseTime}ms` : undefined;
+        const metadata = {
+            method,
+            url,
+            statusCode,
+            responseTime: responseTimeStr,
+        };
+        this.info(`${statusIcon} ${method} ${url} - ${statusCode}`, context || 'HTTP', metadata);
+    }
+    getHttpStatusIcon(statusCode) {
+        if (statusCode >= 200 && statusCode < 300)
+            return '✅';
+        if (statusCode >= 300 && statusCode < 400)
+            return '↩️ ';
+        if (statusCode >= 400 && statusCode < 500)
+            return '⚠️ ';
+        if (statusCode >= 500)
+            return '❌';
+        return '❓';
+    }
+    database(operation, table, duration, context) {
+        const operationIcon = this.getDatabaseOperationIcon(operation);
+        const durationStr = duration ? `${duration}ms` : undefined;
+        const metadata = {
+            operation,
+            table,
+            duration: durationStr,
+        };
+        this.debug(`${operationIcon} ${operation} on ${table}`, context || 'DATABASE', metadata);
+    }
+    getDatabaseOperationIcon(operation) {
+        const op = operation.toUpperCase();
+        if (op.includes('SELECT'))
+            return '🔍';
+        if (op.includes('INSERT'))
+            return '➕';
+        if (op.includes('UPDATE'))
+            return '✏️ ';
+        if (op.includes('DELETE'))
+            return '🗑️ ';
+        if (op.includes('CREATE'))
+            return '🏗️ ';
+        if (op.includes('DROP'))
+            return '💥';
+        return '🗄️ ';
+    }
+    auth(action, userId, context) {
+        const metadata = {
+            action,
+            userId,
+        };
+        this.info(`Auth ${action}`, context, metadata);
+    }
+    trpc(procedure, input, output, duration, context) {
+        const metadata = {
+            procedure,
+            input: input ? JSON.stringify(input) : undefined,
+            output: output ? JSON.stringify(output) : undefined,
+            duration: duration ? `${duration}ms` : undefined,
+        };
+        this.debug(`tRPC ${procedure}`, context, metadata);
+    }
+    // Method to update configuration at runtime
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+        if (newConfig.enableFile && !this.logStream) {
+            this.setupFileLogging();
+        }
+        else if (!newConfig.enableFile && this.logStream) {
+            this.logStream.end();
+            this.logStream = undefined;
+        }
+    }
+    // Progress indicator for long-running operations
+    progress(message, current, total, context) {
+        const percentage = Math.round((current / total) * 100);
+        const progressBar = this.createProgressBar(percentage);
+        this.info(`${progressBar} ${message} (${current}/${total} - ${percentage}%)`, context || 'PROGRESS');
+    }
+    createProgressBar(percentage, width = 20) {
+        const filled = Math.round((percentage / 100) * width);
+        const empty = width - filled;
+        const bar = '█'.repeat(filled) + '░'.repeat(empty);
+        return `[${bar}]`;
+    }
+    // Success and failure helpers
+    success(message, context, metadata) {
+        this.info(`✅ ${message}`, context, metadata);
+    }
+    failure(message, context, metadata, error) {
+        this.error(`❌ ${message}`, context, metadata, error);
+    }
+    // Method to close file streams (useful for graceful shutdown)
+    close() {
+        if (this.logStream) {
+            this.logStream.end();
+        }
+    }
+}
+// Create default logger instance
+const defaultConfig = {
+    level: process.env.NODE_ENV === 'production' ? LogLevel.INFO : LogLevel.DEBUG,
+    enableConsole: true,
+    enableFile: process.env.NODE_ENV === 'production',
+    logDir: './logs',
+    format: process.env.NODE_ENV === 'production' ? 'json' : 'pretty',
+};
+export const logger = new Logger(defaultConfig);
+// Export the Logger class for custom instances
+export { Logger };
+// Graceful shutdown handling
+process.on('SIGINT', () => {
+    logger.info('Received SIGINT, closing logger...');
+    logger.close();
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    logger.info('Received SIGTERM, closing logger...');
+    logger.close();
+    process.exit(0);
+});

package/dist/src/lib/pdf.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 declare function extractPdfText(buffer: Buffer): Promise<ExtractedPdf>;

package/dist/src/lib/pdf.js

@@ -0,0 +1,11 @@
+export async function extractPdfText(buffer) {
+    // 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 = mod.default ?? mod;
+    const data = await pdfParse(buffer);
+    return {
+        text: data.text ?? '',
+        numPages: data.numpages ?? 0,
+    };
+}

package/dist/src/lib/prisma.d.ts

@@ -0,0 +1,3 @@
+import { PrismaClient } from "../../generated/prisma/client.js";
+export { ArtifactType, ActivityLogCategory, ActivityLogStatus, InvoiceType, } from "../../generated/prisma/client.js";
+export declare const prisma: PrismaClient;

package/dist/src/lib/prisma.js

@@ -0,0 +1,15 @@
+import { PrismaPg } from "@prisma/adapter-pg";
+import { PrismaClient } from "../../generated/prisma/client.js";
+export { ArtifactType, ActivityLogCategory, ActivityLogStatus, InvoiceType, } from "../../generated/prisma/client.js";
+const globalForPrisma = globalThis;
+function createPrismaClient() {
+    const connectionString = process.env.DATABASE_URL;
+    if (!connectionString) {
+        throw new Error("DATABASE_URL is not set");
+    }
+    const adapter = new PrismaPg({ connectionString });
+    return new PrismaClient({ adapter });
+}
+export const prisma = globalForPrisma.prisma ?? createPrismaClient();
+if (process.env.NODE_ENV !== "production")
+    globalForPrisma.prisma = prisma;

package/dist/src/lib/pusher.d.ts

@@ -0,0 +1,38 @@
+import Pusher from 'pusher';
+export declare const pusher: Pusher;
+export declare class PusherService {
+    static emitUserEvent(userId: string, eventName: string, data: any): Promise<void>;
+    static emitTaskComplete(workspaceId: string, event: string, data: any): Promise<void>;
+    static emitAnalysisComplete(workspaceId: string, analysisType: string, result: any): Promise<void>;
+    static emitStudyGuideComplete(workspaceId: string, artifact: any): Promise<void>;
+    static emitFlashcardComplete(workspaceId: string, artifact: any): Promise<void>;
+    static emitWorksheetComplete(workspaceId: string, artifact: any): Promise<void>;
+    static emitWorksheetGenerationStart(workspaceId: string): Promise<void>;
+    static emitWorksheetNew(workspaceId: string, worksheet: any): Promise<void>;
+    static emitWorksheetGenerationComplete(workspaceId: string, worksheet: any): Promise<void>;
+    static emitPodcastComplete(workspaceId: string, artifact: any): Promise<void>;
+    static emitOverallComplete(workspaceId: string, filename: string, artifacts: any): Promise<void>;
+    static emitError(workspaceId: string, error: string, analysisType?: string): Promise<void>;
+    static emitAnalysisProgress(workspaceId: string, progress: any): Promise<void>;
+    static emitChannelEvent(channelId: string, event: string, data: any): Promise<void>;
+    static emitMemberJoined(workspaceId: string, member: any): Promise<void>;
+    static emitProfileUpdate(userId: string): Promise<void>;
+    static emitLibraryUpdate(userId: string): Promise<void>;
+    static emitNotificationNew(userId: string, data: {
+        notificationId: string;
+        type: string;
+        title: string;
+        unreadCount: number;
+        createdAt: string;
+    }): Promise<void>;
+    static emitNotificationReadState(userId: string, data: {
+        unreadCount: number;
+        timestamp?: string;
+    }): Promise<void>;
+    static emitPaymentSuccess(userId: string, data: {
+        type: 'topup' | 'subscription';
+        resourceType?: string;
+        quantity?: string;
+    }): Promise<void>;
+}
+export default PusherService;