@goscribe/server 1.1.2 → 1.1.4

package/dist/lib/podcast-prompts.d.ts

@@ -1,43 +0,0 @@
-/**
- * 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

@@ -1,135 +0,0 @@
-/**
- * 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/routers/ai-session.js

@@ -1 +0,0 @@
-"use strict";

package/dist/services/flashcard.service.d.ts

@@ -1,183 +0,0 @@
-import type { PrismaClient } from '@prisma/client';
-import type { CreateFlashcardInput } from '../types/index.js';
-export declare class FlashcardService {
-    private db;
-    constructor(db: PrismaClient);
-    jsonToFlashcards(json: string): Promise<any>;
-    /**
-     * List all flashcard sets for a workspace
-     */
-    listFlashcardSets(workspaceId: string, userId: string): Promise<({
-        flashcards: {
-            id: string;
-            createdAt: Date;
-            artifactId: string;
-            order: number;
-            front: string;
-            back: string;
-            tags: string[];
-        }[];
-    } & {
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-        title: string;
-        description: string | null;
-        workspaceId: string;
-        type: import("@prisma/client").$Enums.ArtifactType;
-        isArchived: boolean;
-        generating: boolean;
-        generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
-        difficulty: import("@prisma/client").$Enums.Difficulty | null;
-        estimatedTime: string | null;
-        imageObjectKey: string | null;
-        createdById: string | null;
-    })[]>;
-    /**
-     * Get a single flashcard set
-     */
-    getFlashcardSet(setId: string, userId: string): Promise<{
-        flashcards: {
-            id: string;
-            createdAt: Date;
-            artifactId: string;
-            order: number;
-            front: string;
-            back: string;
-            tags: string[];
-        }[];
-    } & {
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-        title: string;
-        description: string | null;
-        workspaceId: string;
-        type: import("@prisma/client").$Enums.ArtifactType;
-        isArchived: boolean;
-        generating: boolean;
-        generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
-        difficulty: import("@prisma/client").$Enums.Difficulty | null;
-        estimatedTime: string | null;
-        imageObjectKey: string | null;
-        createdById: string | null;
-    }>;
-    /**
-     * Create a new flashcard set
-     */
-    createFlashcardSet(data: {
-        workspaceId: string;
-        title: string;
-        userId: string;
-        flashcards?: CreateFlashcardInput[];
-    }): Promise<{
-        flashcards: {
-            id: string;
-            createdAt: Date;
-            artifactId: string;
-            order: number;
-            front: string;
-            back: string;
-            tags: string[];
-        }[];
-    } & {
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-        title: string;
-        description: string | null;
-        workspaceId: string;
-        type: import("@prisma/client").$Enums.ArtifactType;
-        isArchived: boolean;
-        generating: boolean;
-        generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
-        difficulty: import("@prisma/client").$Enums.Difficulty | null;
-        estimatedTime: string | null;
-        imageObjectKey: string | null;
-        createdById: string | null;
-    }>;
-    /**
-     * Update a flashcard set
-     */
-    updateFlashcardSet(data: {
-        id: string;
-        title?: string;
-        userId: string;
-        flashcards?: (CreateFlashcardInput & {
-            id?: string;
-        })[];
-    }): Promise<{
-        flashcards: {
-            id: string;
-            createdAt: Date;
-            artifactId: string;
-            order: number;
-            front: string;
-            back: string;
-            tags: string[];
-        }[];
-    } & {
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-        title: string;
-        description: string | null;
-        workspaceId: string;
-        type: import("@prisma/client").$Enums.ArtifactType;
-        isArchived: boolean;
-        generating: boolean;
-        generatingMetadata: import("@prisma/client/runtime/library").JsonValue | null;
-        difficulty: import("@prisma/client").$Enums.Difficulty | null;
-        estimatedTime: string | null;
-        imageObjectKey: string | null;
-        createdById: string | null;
-    }>;
-    /**
-     * Delete a flashcard set
-     */
-    deleteFlashcardSet(setId: string, userId: string): Promise<{
-        success: boolean;
-    }>;
-    /**
-     * Add a flashcard to a set
-     */
-    addFlashcard(data: {
-        setId: string;
-        userId: string;
-        flashcard: CreateFlashcardInput;
-    }): Promise<{
-        id: string;
-        createdAt: Date;
-        artifactId: string;
-        order: number;
-        front: string;
-        back: string;
-        tags: string[];
-    }>;
-    /**
-     * Update a flashcard
-     */
-    updateFlashcard(data: {
-        flashcardId: string;
-        userId: string;
-        updates: Partial<CreateFlashcardInput>;
-    }): Promise<{
-        id: string;
-        createdAt: Date;
-        artifactId: string;
-        order: number;
-        front: string;
-        back: string;
-        tags: string[];
-    }>;
-    /**
-     * Delete a flashcard
-     */
-    deleteFlashcard(flashcardId: string, userId: string): Promise<{
-        success: boolean;
-    }>;
-}
-/**
- * Factory function to create flashcard service
- */
-export declare function createFlashcardService(db: PrismaClient): FlashcardService;

package/dist/services/flashcard.service.js

@@ -1,224 +0,0 @@
-import { NotFoundError } from '../lib/errors.js';
-export class FlashcardService {
-    constructor(db) {
-        this.db = db;
-    }
-    async jsonToFlashcards(json) {
-        const flashcards = JSON.parse(json);
-        return flashcards.map((card) => ({
-            front: card.front,
-            back: card.back,
-        }));
-    }
-    /**
-     * List all flashcard sets for a workspace
-     */
-    async listFlashcardSets(workspaceId, userId) {
-        return this.db.artifact.findMany({
-            where: {
-                workspaceId,
-                type: 'FLASHCARD_SET',
-                workspace: { ownerId: userId },
-            },
-            include: {
-                flashcards: {
-                    orderBy: { order: 'asc' },
-                },
-            },
-            orderBy: { updatedAt: 'desc' },
-        });
-    }
-    /**
-     * Get a single flashcard set
-     */
-    async getFlashcardSet(setId, userId) {
-        const flashcardSet = await this.db.artifact.findFirst({
-            where: {
-                id: setId,
-                type: 'FLASHCARD_SET',
-                workspace: { ownerId: userId },
-            },
-            include: {
-                flashcards: {
-                    orderBy: { order: 'asc' },
-                },
-            },
-        });
-        if (!flashcardSet) {
-            throw new NotFoundError('Flashcard set');
-        }
-        return flashcardSet;
-    }
-    /**
-     * Create a new flashcard set
-     */
-    async createFlashcardSet(data) {
-        // Verify workspace ownership
-        const workspace = await this.db.workspace.findFirst({
-            where: {
-                id: data.workspaceId,
-                ownerId: data.userId,
-            },
-        });
-        if (!workspace) {
-            throw new NotFoundError('Workspace');
-        }
-        const { flashcards, ...setData } = data;
-        return this.db.artifact.create({
-            data: {
-                workspaceId: data.workspaceId,
-                type: 'FLASHCARD_SET',
-                title: data.title,
-                createdById: data.userId,
-                flashcards: flashcards
-                    ? {
-                        create: flashcards.map((card, index) => ({
-                            ...card,
-                            order: card.order ?? index,
-                        })),
-                    }
-                    : undefined,
-            },
-            include: {
-                flashcards: {
-                    orderBy: { order: 'asc' },
-                },
-            },
-        });
-    }
-    /**
-     * Update a flashcard set
-     */
-    async updateFlashcardSet(data) {
-        const { id, flashcards, userId, ...updateData } = data;
-        // Verify ownership
-        const existingSet = await this.db.artifact.findFirst({
-            where: {
-                id,
-                type: 'FLASHCARD_SET',
-                workspace: { ownerId: userId },
-            },
-        });
-        if (!existingSet) {
-            throw new NotFoundError('Flashcard set');
-        }
-        // Handle flashcards update if provided
-        if (flashcards) {
-            // Delete existing flashcards
-            await this.db.flashcard.deleteMany({
-                where: { artifactId: id },
-            });
-            // Create new flashcards
-            await this.db.flashcard.createMany({
-                data: flashcards.map((card, index) => ({
-                    artifactId: id,
-                    front: card.front,
-                    back: card.back,
-                    tags: card.tags || [],
-                    order: card.order ?? index,
-                })),
-            });
-        }
-        return this.db.artifact.update({
-            where: { id },
-            data: updateData,
-            include: {
-                flashcards: {
-                    orderBy: { order: 'asc' },
-                },
-            },
-        });
-    }
-    /**
-     * Delete a flashcard set
-     */
-    async deleteFlashcardSet(setId, userId) {
-        const deleted = await this.db.artifact.deleteMany({
-            where: {
-                id: setId,
-                type: 'FLASHCARD_SET',
-                workspace: { ownerId: userId },
-            },
-        });
-        if (deleted.count === 0) {
-            throw new NotFoundError('Flashcard set');
-        }
-        return { success: true };
-    }
-    /**
-     * Add a flashcard to a set
-     */
-    async addFlashcard(data) {
-        // Verify ownership
-        const set = await this.db.artifact.findFirst({
-            where: {
-                id: data.setId,
-                type: 'FLASHCARD_SET',
-                workspace: { ownerId: data.userId },
-            },
-        });
-        if (!set) {
-            throw new NotFoundError('Flashcard set');
-        }
-        // Get the next order number
-        const maxOrder = await this.db.flashcard.aggregate({
-            where: { artifactId: data.setId },
-            _max: { order: true },
-        });
-        return this.db.flashcard.create({
-            data: {
-                artifactId: data.setId,
-                front: data.flashcard.front,
-                back: data.flashcard.back,
-                tags: data.flashcard.tags || [],
-                order: data.flashcard.order ?? (maxOrder._max.order ?? 0) + 1,
-            },
-        });
-    }
-    /**
-     * Update a flashcard
-     */
-    async updateFlashcard(data) {
-        // Verify ownership
-        const flashcard = await this.db.flashcard.findFirst({
-            where: {
-                id: data.flashcardId,
-                artifact: {
-                    type: 'FLASHCARD_SET',
-                    workspace: { ownerId: data.userId },
-                },
-            },
-        });
-        if (!flashcard) {
-            throw new NotFoundError('Flashcard');
-        }
-        return this.db.flashcard.update({
-            where: { id: data.flashcardId },
-            data: data.updates,
-        });
-    }
-    /**
-     * Delete a flashcard
-     */
-    async deleteFlashcard(flashcardId, userId) {
-        const flashcard = await this.db.flashcard.findFirst({
-            where: {
-                id: flashcardId,
-                artifact: { workspace: { ownerId: userId } },
-            },
-        });
-        if (!flashcard) {
-            throw new NotFoundError('Flashcard');
-        }
-        await this.db.flashcard.delete({
-            where: { id: flashcardId },
-        });
-        return { success: true };
-    }
-}
-/**
- * Factory function to create flashcard service
- */
-export function createFlashcardService(db) {
-    return new FlashcardService(db);
-}

package/dist/services/podcast-segment-reorder.js

@@ -1,107 +0,0 @@
-"use strict";
-// import type { PrismaClient } from '@prisma/client';
-// import { NotFoundError } from '../lib/errors.js';
-// export interface ReorderSegmentData {
-//   id: string;
-//   newOrder: number;
-// }
-// export class PodcastSegmentReorderService {
-//   constructor(private db: PrismaClient) {}
-//   /**
-//    * Reorder podcast segments and recalculate start times
-//    */
-//   async reorderSegments(data: {
-//     episodeId: string;
-//     userId: string;
-//     newOrder: ReorderSegmentData[];
-//   }) {
-//     const { episodeId, userId, newOrder } = data;
-//     // Verify ownership
-//     const episode = await this.db.artifact.findFirst({
-//       where: {
-//         id: episodeId,
-//         type: 'PODCAST_EPISODE',
-//         workspace: { ownerId: userId },
-//       },
-//       include: {
-//         podcastSegments: {
-//           orderBy: { order: 'asc' },
-//         },
-//       },
-//     });
-//     if (!episode) {
-//       throw new NotFoundError('Podcast episode');
-//     }
-//     // Validate all segment IDs exist
-//     const segmentIds = episode.podcastSegments.map((s) => s.id);
-//     const invalidIds = newOrder.filter((item) => !segmentIds.includes(item.id));
-//     if (invalidIds.length > 0) {
-//       throw new Error(`Invalid segment IDs: ${invalidIds.map((i) => i.id).join(', ')}`);
-//     }
-//     // Validate order values are sequential
-//     const orderValues = newOrder.map((item) => item.newOrder).sort((a, b) => a - b);
-//     const expectedOrder = Array.from({ length: newOrder.length }, (_, i) => i + 1);
-//     if (JSON.stringify(orderValues) !== JSON.stringify(expectedOrder)) {
-//       throw new Error('Order values must be sequential starting from 1');
-//     }
-//     return this.db.$transaction(async (tx) => {
-//       // Update each segment's order
-//       for (const item of newOrder) {
-//         await tx.podcastSegment.update({
-//           where: { id: item.id },
-//           data: { order: item.newOrder },
-//         });
-//       }
-//       // Get all segments in new order
-//       const reorderedSegments = await tx.podcastSegment.findMany({
-//         where: { artifactId: episodeId },
-//         orderBy: { order: 'asc' },
-//       });
-//       // Recalculate start times
-//       let currentTime = 0;
-//       for (const segment of reorderedSegments) {
-//         await tx.podcastSegment.update({
-//           where: { id: segment.id },
-//           data: { startTime: currentTime },
-//         });
-//         currentTime += segment.duration;
-//       }
-//       // Update total duration in latest version
-//       const latestVersion = await tx.artifactVersion.findFirst({
-//         where: { artifactId: episodeId },
-//         orderBy: { version: 'desc' },
-//       });
-//       if (latestVersion) {
-//         const metadata = latestVersion.data as any;
-//         if (metadata) {
-//           metadata.totalDuration = currentTime;
-//           // Create new version with updated metadata
-//           await tx.artifactVersion.create({
-//             data: {
-//               artifactId: episodeId,
-//               version: latestVersion.version + 1,
-//               content: latestVersion.content,
-//               data: metadata,
-//               createdById: userId,
-//             },
-//           });
-//         }
-//       }
-//       // Update artifact timestamp
-//       await tx.artifact.update({
-//         where: { id: episodeId },
-//         data: { updatedAt: new Date() },
-//       });
-//       return {
-//         totalDuration: currentTime,
-//         segmentsReordered: reorderedSegments.length,
-//       };
-//     });
-//   }
-// }
-// /**
-//  * Factory function
-//  */
-// export function createPodcastSegmentReorderService(db: PrismaClient) {
-//   return new PodcastSegmentReorderService(db);
-// }