Building an AI YouTube Video Summarizer: From Video Link to Summary

const getVideoMetadata = async (videoUrl) => {
  try {
    const videoId = extractVideoId(videoUrl);
    const response = await youtube.videos.list({
      part: 'snippet,contentDetails',
      id: videoId
    });

    return {
      title: response.data.items[0].snippet.title,
      description: response.data.items[0].snippet.description,
      duration: response.data.items[0].contentDetails.duration
    };
  } catch (error) {
    console.error('Failed to fetch metadata:', error);
    throw error;
  }
};

const getTranscript = async (videoId) => {
  try {
    const transcript = await YoutubeTranscript.fetchTranscript(videoId);
    return transcript.map(item => item.text).join(' ');
  } catch (error) {
    console.error('Failed to fetch transcript:', error);
    throw error;
  }
};

const generateSummary = async (transcript, summaryType) => {
  const prompts = {
    quick: "Provide a brief 2-3 sentence summary of the main points:",
    detailed: "Provide a detailed summary with key points and examples:",
    bullets: "List the main points as bullet points:",
  };

  try {
    const completion = await openai.createChatCompletion({
      model: "gpt-4",
      messages: [{
        role: "user",
        content: `${prompts[summaryType]} ${transcript}`
      }]
    });

    return completion.data.choices[0].message.content;
  } catch (error) {
    console.error('Failed to generate summary:', error);
    throw error;
  }
};

interface SummaryResult {
  metadata: VideoMetadata;
  transcript: string;
  summary: string;
}

const processVideo = async (
  videoUrl: string, 
  summaryType: 'quick' | 'detailed' | 'bullets'
): Promise<SummaryResult> => {
  const metadata = await getVideoMetadata(videoUrl);
  const transcript = await getTranscript(videoUrl);
  const summary = await generateSummary(transcript, summaryType);

  return {
    metadata,
    transcript,
    summary
  };
};