@goscribe/server 1.0.11 → 1.1.0

package/dist/lib/logger.js

@@ -0,0 +1,342 @@
+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) {
+        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, context, metadata, error) {
+        this.log(LogLevel.ERROR, message, context, metadata, error);
+    }
+    warn(message, context, metadata) {
+        this.log(LogLevel.WARN, message, context, metadata);
+    }
+    info(message, context, metadata) {
+        this.log(LogLevel.INFO, message, context, metadata);
+    }
+    debug(message, context, metadata) {
+        this.log(LogLevel.DEBUG, message, context, 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/lib/podcast-prompts.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Podcast generation prompts
+ */
+export interface StructurePromptParams {
+    title: string;
+    description?: string;
+    userPrompt: string;
+    studyGuideContent: string;
+    generateIntro: boolean;
+    generateOutro: boolean;
+}
+export interface RegenerateSegmentPromptParams {
+    oldContent: string;
+    userPrompt: string;
+    segmentTitle: string;
+    context: {
+        episodeTitle: string;
+        allSegmentTitles: string[];
+        segmentIndex: number;
+    };
+}
+/**
+ * Generate prompt for structuring podcast content
+ */
+export declare function createStructurePrompt(params: StructurePromptParams): string;
+/**
+ * Generate prompt for episode summary
+ */
+export declare function createSummaryPrompt(episodeTitle: string, segments: Array<{
+    title: string;
+    keyPoints: string[];
+}>): string;
+/**
+ * Generate improved prompt for segment regeneration
+ */
+export declare function createRegenerateSegmentPrompt(params: RegenerateSegmentPromptParams): string;
+/**
+ * Validate environment for podcast generation
+ */
+export declare function validatePodcastEnvironment(): {
+    valid: boolean;
+    errors: string[];
+};

package/dist/lib/podcast-prompts.js

@@ -0,0 +1,135 @@
+/**
+ * Podcast generation prompts
+ */
+/**
+ * Generate prompt for structuring podcast content
+ */
+export function createStructurePrompt(params) {
+    const { title, description, userPrompt, studyGuideContent, generateIntro, generateOutro } = params;
+    return `You are an expert podcast content creator and scriptwriter. Your task is to create an engaging, educational podcast episode with professional structure and natural conversational language.
+
+OBJECTIVE:
+Create a complete podcast episode that is informative, engaging, and flows naturally. The content should be suitable for audio delivery with a conversational tone.
+
+USER REQUEST:
+Title: ${title}
+Description: ${description || 'No description provided'}
+Prompt: ${userPrompt}
+
+REQUIREMENTS:
+1. Create segments that are 2-5 minutes each when spoken at a normal pace
+2. Use natural, conversational language (avoid reading lists, use storytelling)
+3. Include smooth transitions between segments
+4. Each segment should have a clear focus and takeaways
+5. Make content accessible but informative
+${generateIntro ? '6. Start with an engaging hook that captures attention immediately' : ''}
+${generateOutro ? '7. End with a strong conclusion that summarizes and motivates action' : ''}
+
+CONTEXT (if available):
+${studyGuideContent ? `Study Guide Content (use as reference, don't copy verbatim):\n${studyGuideContent.substring(0, 2000)}` : 'No study guide available'}
+
+OUTPUT FORMAT (strict JSON):
+{
+  "episodeTitle": "Enhanced, engaging title for the podcast",
+  "totalEstimatedDuration": "XX minutes",
+  "segments": [
+    {
+      "title": "Segment title (concise and descriptive)",
+      "content": "Natural conversational script. Use 'I', 'we', 'you'. Tell stories. Ask rhetorical questions. Use analogies. Make it sound like a real conversation, not a lecture.",
+      "keyPoints": ["Main point 1", "Main point 2", "Main point 3"],
+      "estimatedDuration": "X minutes",
+      "order": 1
+    }
+  ]
+}
+
+IMPORTANT:
+- Write like you're having a conversation with a friend
+- Use contractions (I'm, you're, let's)
+- Include verbal cues ("Now, here's the interesting part...", "You know what's fascinating?")
+- Vary sentence length for natural rhythm
+- Each segment should be self-contained but connected to the narrative
+
+Return ONLY the JSON, no additional text.`;
+}
+/**
+ * Generate prompt for episode summary
+ */
+export function createSummaryPrompt(episodeTitle, segments) {
+    return `Create a comprehensive analysis and summary for this podcast episode.
+
+EPISODE: "${episodeTitle}"
+
+SEGMENTS:
+${JSON.stringify(segments, null, 2)}
+
+Generate a detailed summary with the following structure (return as JSON):
+
+{
+  "executiveSummary": "2-3 sentence overview of what listeners will learn",
+  "learningObjectives": ["Specific, actionable objectives (3-5 items)"],
+  "keyConcepts": ["Main concepts covered (5-7 items)"],
+  "followUpActions": ["Concrete next steps listeners can take (3-5 items)"],
+  "targetAudience": "Detailed description of who will benefit most",
+  "prerequisites": ["Knowledge or background helpful but not required (2-3 items, or empty array)"],
+  "tags": ["Relevant searchable tags (5-8 items)"]
+}
+
+Make it specific, actionable, and useful for potential listeners trying to decide if this episode is for them.
+
+Return ONLY the JSON, no additional text.`;
+}
+/**
+ * Generate improved prompt for segment regeneration
+ */
+export function createRegenerateSegmentPrompt(params) {
+    const { oldContent, userPrompt, segmentTitle, context } = params;
+    return `You are revising a specific segment of a podcast episode.
+
+EPISODE CONTEXT:
+- Episode Title: "${context.episodeTitle}"
+- All Segments: ${context.allSegmentTitles.map((t, i) => `${i + 1}. ${t}`).join(', ')}
+- Current Segment: #${context.segmentIndex + 1} - "${segmentTitle}"
+
+CURRENT CONTENT:
+"""
+${oldContent}
+"""
+
+USER REQUEST FOR REVISION:
+"""
+${userPrompt}
+"""
+
+TASK:
+Rewrite this segment following the user's request while maintaining:
+1. Natural, conversational tone
+2. Connection to the overall episode narrative
+3. Appropriate length (2-5 minutes spoken)
+4. Engaging and informative content
+
+GUIDELINES:
+- If user asks to make it "longer", expand on concepts with examples and stories
+- If user asks to make it "shorter", focus on key points and remove tangents
+- If user asks to "add more detail", include specific examples, data, or anecdotes
+- If user asks to "simplify", use clearer language and better analogies
+- If user asks to "make it more engaging", add hooks, questions, and storytelling
+
+Return ONLY the revised content as plain text, no JSON or formatting. Write as if you're speaking to listeners.`;
+}
+/**
+ * Validate environment for podcast generation
+ */
+export function validatePodcastEnvironment() {
+    const errors = [];
+    if (!process.env.MURF_TTS_KEY) {
+        errors.push('MURF_TTS_KEY environment variable is not set');
+    }
+    if (!process.env.INFERENCE_API_URL && !process.env.OPENAI_API_KEY) {
+        errors.push('No AI inference API configured (need INFERENCE_API_URL or OPENAI_API_KEY)');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}

package/dist/lib/pusher.d.ts

@@ -9,6 +9,7 @@ export declare class PusherService {
     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>;
 }
 export default PusherService;

package/dist/lib/pusher.js

@@ -1,4 +1,5 @@
 import Pusher from 'pusher';
+import { logger } from './logger.js';
 // Server-side Pusher instance
 export const pusher = new Pusher({
     appId: process.env.PUSHER_APP_ID || '',
@@ -13,9 +14,9 @@ export class PusherService {
     static async emitTaskComplete(workspaceId, event, data) {
         try {
             const channel = `workspace_${workspaceId}`;
-            const eventName = `${workspaceId}_${event}`;
+            const eventName = event;
             await pusher.trigger(channel, eventName, data);
-            console.log(`📡 Pusher notification sent: ${eventName} to ${channel}`);
+            logger.info(`📡 Pusher notification sent: ${eventName} to ${channel}`);
         }
         catch (error) {
             console.error('❌ Pusher notification error:', error);
@@ -78,6 +79,17 @@ export class PusherService {
             timestamp: new Date().toISOString(),
         });
     }
+    // Emit analysis progress update (single event for all progress updates)
+    static async emitAnalysisProgress(workspaceId, progress) {
+        try {
+            const channel = `workspace_${workspaceId}`;
+            await pusher.trigger(channel, 'analysis_progress', progress);
+            logger.info(`📡 Analysis progress sent to ${channel}: ${progress.status}`);
+        }
+        catch (error) {
+            console.error('❌ Pusher progress notification error:', error);
+        }
+    }
     // Emit channel-specific events (for chat messages)
     static async emitChannelEvent(channelId, event, data) {
         try {

package/dist/lib/storage.d.ts

@@ -3,9 +3,9 @@ export interface UploadResult {
     signedUrl?: string;
     objectKey: string;
 }
-export declare function uploadToGCS(fileBuffer: Buffer, fileName: string, contentType: string, makePublic?: boolean): Promise<UploadResult>;
+export declare function uploadToSupabase(fileBuffer: Buffer, fileName: string, contentType: string, makePublic?: boolean): Promise<UploadResult>;
 export declare function generateSignedUrl(objectKey: string, expiresInHours?: number): Promise<string>;
-export declare function deleteFromGCS(objectKey: string): Promise<void>;
+export declare function deleteFromSupabase(objectKey: string): Promise<void>;
 export declare function makeFilePublic(objectKey: string): Promise<void>;
 export declare function makeFilePrivate(objectKey: string): Promise<void>;
-export declare const bucket: import("@google-cloud/storage").Bucket;
+export declare const supabaseClient: import("@supabase/supabase-js").SupabaseClient<any, "public", "public", any, any>;