Can I vibecode VidNotes?

You are an expert AI coding assistant. Your task is to build a complete, production-ready, locally-hosted web application that replicates the core features of VidNotes.

Create a local video-to-notes and study platform to serve as a comprehensive VidNotes alternative. The application must feature a highly polished, modern UI with rich aesthetics, glassmorphism, dynamic micro-animations, and a cohesive dark mode tailored for deep work. It should be built as a Python 3.12 backend utilizing FastAPI and SQLite (with FTS5 for full-text search), paired with a responsive frontend powered by HTMX, Jinja templates, and Vanilla CSS or Tailwind CSS.

### Core Architecture and Ingestion
- The home screen must elegantly accept YouTube URLs (via `yt-dlp`) or direct media uploads (MP4, MOV, M4A, MP3).
- Utilize `ffmpeg` to extract and normalize mono audio.
- Implement background task processing showing real-time UI states: queued, extracting, transcribing, generating, complete, and failed.

### AI Transcription and Synthesis
- Use the OpenAI Python SDK (or local whisper.cpp if configured) to generate highly accurate, timestamped speech-to-text transcripts. Ensure large files are chunked appropriately while preserving timestamp offsets.
- Develop a "Result View" featuring an integrated media player adjacent to a searchable, interactive transcript. Clicking any word or sentence in the transcript must jump the media player to that exact timestamp.
- Automatically generate AI-powered synthesis using LLM endpoints:
  - A concise 5-bullet summary and overarching key takeaways.
  - Action items, decisions, and deadlines extracted from the content.
  - A set of 10 study flashcards and a 5-question multiple-choice quiz to reinforce learning.
- Provide a regenerate button for all AI-generated sections.

### Interactive Features
- Implement a "Chat with Video" feature: a sidebar AI chatbot that acts as a tutor or research assistant, answering questions specifically based on the video's transcript and context.
- Allow users to highlight sections of the transcript to save as "moments" or quotes into a personal knowledge management view.

### Storage, Export, and Privacy
- Store all metadata, extracted action items, study materials, and transcripts in SQLite. Media should be saved locally under `./data/projects/<uuid>/`.
- Provide versatile export options: Markdown, TXT, SRT/VTT (for subtitles), PDF, and JSON.
- Ensure all data remains entirely local with absolutely no telemetry or account requirements. OpenAI API calls and `yt-dlp` downloads are the only external network requests permitted.
- Out of scope: native mobile apps, cross-device sync, Chrome extensions, or public APIs.

### Setup and Documentation
- Provide a comprehensive `README.md` detailing setup instructions, `ffmpeg` and `yt-dlp` installation across platforms, a `.env.example` file for API keys, and data deletion steps.
- Include a warning that third-party site structure changes (like YouTube) may temporarily break URL ingestion.

# Detailed Requirements
1. **User Interface & Experience:**
   - Build a stunning landing/dashboard page with an empty state that clearly guides the user to upload or process their first item.
   - Implement real-time progress indicators (e.g., circular progress bars, skeleton loaders) during long-running tasks.
   - Ensure the application is fully responsive. Mobile layouts should gracefully stack elements, while desktop layouts should take advantage of widescreen real estate for complex timelines or data tables.
   - Add hover states, active states, and subtle layout transitions using Framer Motion so the application feels alive and premium.

2. **Backend & Processing:**
   - Set up a secure and modular backend structure. All environment variables (like API keys for LLMs or external services) must be loaded from a `.env` file. Provide a `.env.example`.
   - Implement robust error handling. If a processing step fails, the UI should gracefully explain the issue and allow the user to retry without losing their session context.
   - For audio/video processing, use local instances of FFmpeg. For transcription or AI tasks, integrate with OpenAI's API or use local models (like Whisper.cpp or Ollama) to guarantee privacy and control.
   - Data should be saved locally in a SQLite database with schemas that clearly link media assets to their processed metadata (transcripts, summaries, edit markers).

3. **Application State & Export:**
   - Use standard state management (like Zustand or React Context) to manage the user's current project.
   - Provide a highly visible "Export" mechanism. Users should be able to download their final assets (e.g., Markdown files, MP3/MP4 files, JSON manifests) with a single click in a nicely packaged format.

4. **Code Quality & Constraints:**
   - Write clean, modular, and well-documented code. Split React components into logical, reusable pieces (e.g., `MediaUploader`, `TimelineEditor`, `TranscriptView`).
   - Do not implement any user authentication, cloud syncing, billing, or telemetry. This is a strictly local, single-player application designed for maximum privacy and utility.
   - Do not hallucinate external integrations (like CRM syncing or automatic publishing to platforms). Keep the scope strictly to local processing and export.
   - Include a comprehensive README.md detailing the exact commands to install dependencies, start the frontend and backend servers, and any system-level prerequisites (like installing FFmpeg).

Begin your implementation by setting up the project scaffolding, then build the UI skeleton, integrate the backend processing pipelines, and finally polish the UI with animations and responsive tweaks.