refactor: Replace video analyzer with blank Gradio 6 project

- Remove all existing source code, tests, and documentation
- Add minimal pyproject.toml with Gradio 6 dependency
- Add blank app.py with simple Gradio interface
- Add README.md with HuggingFace Spaces YAML frontmatter
- Generate uv.lock for dependency management

.cursorrules

@@ -1,71 +0,0 @@
-# Cursor Engineering Ruleset
-
-## 1. Context First
-Always request full context and constraints before proposing any decision.
-- Understand the problem completely before suggesting solutions
-- Ask clarifying questions when requirements are ambiguous
-- Consider existing codebase patterns and conventions
-
-## 2. Tech Stack Principles
-Recommend tech stacks using:
-- Idiomatic, native patterns for the language/framework
-- Simple and maintainable components
-- Minimal unnecessary abstraction
-- Prefer standard library over external dependencies when reasonable
-
-## 3. Scaffold Before Implementation
-Scaffold the project structure BEFORE implementation:
-- Clear domain boundaries
-- Clean folder organization
-- Conventional naming (language-specific conventions)
-- Consistent imports/exports
-- Document the structure in README
-
-## 4. Test-Driven Development (TDD)
-Use TDD approach:
-- Tests define behavior before implementation
-- Define what failure looks like explicitly
-- No implementation until tests exist
-- Edge cases explicitly covered
-- Tests should be readable as documentation
-
-## 5. Idempotent Functions
-All core functions must be idempotent:
-- Deterministic behavior (same input → same output)
-- Safe to re-run multiple times
-- No hidden state or side effects
-- Pure functions where possible
-
-## 6. Simplicity First
-Optimize for simplicity:
-- Low cognitive load
-- Readable and clean code
-- Avoid cleverness and "magic"
-- Avoid premature optimization
-- YAGNI (You Aren't Gonna Need It)
-- DRY (Don't Repeat Yourself) but not at the cost of clarity
-
-## 7. Idiomatic Code
-Use idiomatic language patterns at all times:
-- Follow language-specific style guides
-- Use conventional patterns for the ecosystem
-- Leverage language features appropriately
-- Write code that looks familiar to other developers
-
----
-
-## Project-Specific Rules
-
-### Video Analyzer Project
-- Use 100% free and open-source tools
-- Prefer local processing over cloud APIs
-- Keep user data private (process locally)
-- Support both CLI and future web UI
-- Modular architecture for easy extension
-
-### Python Conventions
-- Type hints on all function signatures
-- Docstrings for public functions
-- Use pathlib for file paths
-- Rich for CLI output
-- Pydantic for configuration/validation

.env.example

@@ -1,12 +0,0 @@
-# Video Analyzer - Environment Variables
-# Copy this file to .env and fill in your values
-
-# Hugging Face API Key (optional - for faster API-based summarization)
-# Get your free key at: https://huggingface.co/settings/tokens
-HUGGINGFACE_API_KEY=your_token_here
-
-# Whisper Model Size (tiny, base, small, medium, large-v3)
-VIDEO_ANALYZER_WHISPER_MODEL=base
-
-# Default AI Backend (ollama, huggingface, huggingface-api)
-VIDEO_ANALYZER_AI_BACKEND=huggingface

.gitignore

@@ -1,38 +1,39 @@
-# Environment variables (contains secrets!)
-.env
-.env.local
-
 # Python
 __pycache__/
 *.py[cod]
 *$py.class
 *.so
 .Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
 .venv/
 venv/
 ENV/
 
-# Data directories (large files)
-data/downloads/
-data/audio/
-data/chromadb/
-
-# Keep transcripts and summaries (text files are small)
-# data/transcripts/
-# data/summaries/
-
-# Models cache
-models/
-
 # IDE
 .idea/
 .vscode/
 *.swp
 *.swo
 
-# OS
-.DS_Store
-Thumbs.db
+# Environment
+.env
+.env.local
 
-# Logs
-*.log
+# uv
+.python-version

DEPLOY_TO_HF_SPACES.md

@@ -1,134 +0,0 @@
-# Deploy to HuggingFace Spaces
-
-This guide will help you deploy your Real Estate Mentor to HuggingFace Spaces for free.
-
-## What You'll Get
-
-- 🌐 **Public URL** - Access from anywhere
-- 💾 **Persistent Storage** - Your data is saved
-- 🆓 **100% Free** - No cost on free tier
-- 🔒 **Private Option** - Can make it private
-
----
-
-## Step 1: Create a New Space
-
-1. Go to: https://huggingface.co/new-space
-
-2. Fill in:
-   ```
-   Space name:     real-estate-mentor
-   License:        MIT
-   SDK:            Gradio
-   Hardware:       CPU Basic (Free)
-   Visibility:     Public (or Private)
-   ```
-
-3. Click **"Create Space"**
-
----
-
-## Step 2: Upload Files
-
-### Option A: Upload via Web Interface
-
-1. In your new Space, click **"Files"** tab
-2. Click **"+ Add file"** → **"Upload files"**
-3. Upload these files from the `hf_space/` folder:
-   - `app.py`
-   - `requirements.txt`
-   - `README.md`
-
-### Option B: Use Git (Recommended)
-
-```bash
-# Clone your space
-git clone https://huggingface.co/spaces/YOUR_USERNAME/real-estate-mentor
-cd real-estate-mentor
-
-# Copy files from hf_space/
-cp /path/to/video_analyzer/hf_space/* .
-
-# Push to HuggingFace
-git add .
-git commit -m "Initial deployment"
-git push
-```
-
----
-
-## Step 3: Wait for Build
-
-1. Go to your Space URL: `https://huggingface.co/spaces/YOUR_USERNAME/real-estate-mentor`
-2. Watch the **"Building"** status
-3. First build takes ~3-5 minutes (downloading models)
-4. When ready, you'll see **"Running"** ✅
-
----
-
-## Step 4: Enable Persistent Storage
-
-**Important:** To keep your data between restarts:
-
-1. Go to Space **Settings**
-2. Find **"Persistent Storage"**
-3. Enable it (free tier: up to 50GB)
-
-This ensures your indexed content survives Space restarts.
-
----
-
-## Step 5: Start Using It!
-
-1. **Upload Tab** - Add your course transcripts
-2. **Search Tab** - Find content semantically
-3. **Ask Tab** - Chat with your AI mentor
-4. **Status Tab** - See what's indexed
-
----
-
-## Troubleshooting
-
-### Space is "Sleeping"
-
-Free Spaces sleep after ~15 minutes of inactivity. Just visit the URL and it will wake up (takes ~30 seconds).
-
-### Build Failed
-
-Check the **Logs** tab for errors. Common issues:
-- Missing dependencies → Check `requirements.txt`
-- Syntax errors → Check `app.py`
-
-### Data Disappeared
-
-Make sure **Persistent Storage** is enabled in Settings.
-
----
-
-## Upgrading (Optional)
-
-For faster performance, you can upgrade hardware:
-
-| Tier | Cost | Benefits |
-|------|------|----------|
-| CPU Basic | Free | Works fine, sleeps after 15 min |
-| CPU Upgrade | $0.03/hr | Faster, no sleep |
-| GPU | $0.60/hr | Much faster embeddings |
-
----
-
-## Files Reference
-
-```
-hf_space/
-├── app.py              # Main Gradio application
-├── requirements.txt    # Python dependencies
-└── README.md           # Space description (shows on page)
-```
-
----
-
-## Need Help?
-
-- HuggingFace Docs: https://huggingface.co/docs/hub/spaces
-- Gradio Docs: https://gradio.app/docs/

PLAN.md

@@ -1,437 +0,0 @@
-# Video Analyzer - Project Plan
-
-## Overview
-A comprehensive tool to download videos from multiple sources, transcribe them to text, summarize content, and build a searchable knowledge base. The end goal is to create a **Virtual Real Estate Mentor** from course materials.
-
-**🆓 100% Free & Open Source - No API costs!**
-
----
-
-## Tech Stack (All Free & Open Source)
-
-| Component | Technology | License | Notes |
-|-----------|------------|---------|-------|
-| **Language** | Python 3.11+ | PSF | Main language |
-| **Video Download** | yt-dlp | Unlicense | Supports 1000+ sites |
-| **Audio Processing** | ffmpeg | LGPL/GPL | Industry standard |
-| **Transcription** | Whisper.cpp / faster-whisper | MIT | Local, fast, accurate |
-| **Document Parsing** | PyMuPDF, python-docx | AGPL/MIT | PDF, Word support |
-| **OCR** | Tesseract | Apache 2.0 | Image text extraction |
-| **Vector DB** | ChromaDB | Apache 2.0 | Local vector storage |
-| **Embeddings** | sentence-transformers | Apache 2.0 | all-MiniLM-L6-v2 model |
-| **LLM** | Ollama + Llama3/Mistral/Phi | Various OSS | Local AI, no API costs |
-| **Web UI** | Gradio | Apache 2.0 | Simple, beautiful UI |
-| **CLI** | Typer | MIT | Command-line interface |
-| **Database** | SQLite | Public Domain | Metadata storage |
-
----
-
-## Core Features
-
-### 1. Multi-Source Video Downloader
-- **Supported Platforms:**
-  - YouTube, Vimeo, Dailymotion
-  - Udemy (with cookies/auth)
-  - Teachable, Thinkific, Kajabi
-  - Direct video URLs (MP4, WebM, etc.)
-  - Google Drive, Dropbox links
-- **Technology:** `yt-dlp` (free, actively maintained)
-- **Features:**
-  - Playlist/batch downloading
-  - Quality selection
-  - Resume interrupted downloads
-  - Metadata extraction (title, description, chapters)
-  - Cookie-based authentication for paid courses
-
-### 2. Audio Extraction & Transcription
-- **Audio Extraction:** `ffmpeg` (free)
-- **Speech-to-Text:** 
-  - **faster-whisper** - CTranslate2 optimized, 4x faster than original
-  - Models: tiny, base, small, medium, large-v3
-  - Runs entirely local - no internet needed
-- **Features:**
-  - Speaker diarization (with pyannote - free for research)
-  - Word-level timestamps
-  - Multiple language support (99 languages)
-  - Auto language detection
-
-### 3. Document Processing
-- **Supported Formats:**
-  - PDF (PyMuPDF - fast, accurate)
-  - Word documents (python-docx)
-  - PowerPoint slides (python-pptx)
-  - Images with text (Tesseract OCR)
-  - Markdown, TXT, HTML
-- **All libraries are free and open source**
-
-### 4. Local LLM for Summarization & Analysis
-- **Ollama** - Run LLMs locally with simple API
-- **Recommended Models (all free):**
-  | Model | Size | Speed | Quality | Best For |
-  |-------|------|-------|---------|----------|
-  | Phi-3 | 3.8B | ⚡⚡⚡ | Good | Fast summaries |
-  | Mistral | 7B | ⚡⚡ | Great | Balanced |
-  | Llama3 | 8B | ⚡⚡ | Excellent | Best quality |
-  | Llama3 | 70B | ⚡ | Outstanding | If you have GPU |
-
-- **Features:**
-  - Quick summaries
-  - Detailed study notes
-  - Key concept extraction
-  - Action items and strategies
-  - Q&A over content
-
-### 5. Knowledge Base & Vector Storage
-- **ChromaDB** - Local vector database (free)
-- **Embeddings:** sentence-transformers
-  - Model: `all-MiniLM-L6-v2` (fast, 384 dimensions)
-  - Alternative: `all-mpnet-base-v2` (better quality, slower)
-- **Features:**
-  - Semantic search across all content
-  - Source attribution with timestamps
-  - Hybrid search (semantic + keyword)
-  - No cloud, all local
-
-### 6. Virtual Mentor Chat Interface
-- **RAG (Retrieval Augmented Generation):**
-  - Query → Find relevant chunks → Generate response
-  - All runs locally with Ollama
-- **Interfaces:**
-  - CLI chat (terminal)
-  - Web UI (Gradio - beautiful, easy)
-- **Features:**
-  - Context-aware responses
-  - Source citations
-  - Conversation memory
-  - Export chat history
-
----
-
-## Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                   VIDEO ANALYZER (100% Local)                   │
-├─────────────────────────────────────────────────────────────────┤
-│                                                                 │
-│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────┐  │
-│  │   Ingestion  │  │  Processing  │  │    Knowledge Base    │  │
-│  ├──────────────┤  ├──────────────┤  ├──────────────────────┤  │
-│  │ • yt-dlp     │  │ • ffmpeg     │  │ • ChromaDB           │  │
-│  │ • Cookies    │→ ��� • Whisper    │→ │ • sentence-transform │  │
-│  │ • File input │  │ • Tesseract  │  │ • SQLite metadata    │  │
-│  └──────────────┘  └──────────────┘  └──────────────────────┘  │
-│                                                                 │
-│                              ↓                                  │
-│                                                                 │
-│  ┌──────────────────────────────────────────────────────────┐  │
-│  │              Virtual Mentor (Ollama + RAG)                │  │
-│  ├──────────────────────────────────────────────────────────┤  │
-│  │  • Llama3 / Mistral / Phi-3 (your choice)                 │  │
-│  │  • Context retrieval from ChromaDB                        │  │
-│  │  • Local inference - no API calls                         │  │
-│  │  • Gradio web interface                                   │  │
-│  └──────────────────────────────────────────────────────────┘  │
-│                                                                 │
-└─────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## System Requirements
-
-### Minimum (CPU only)
-- **RAM:** 8GB (16GB recommended)
-- **Storage:** 20GB+ for models and data
-- **CPU:** Any modern x64 processor
-- **Whisper:** Use "small" or "base" model
-- **LLM:** Use Phi-3 (3.8B) model
-
-### Recommended (with GPU)
-- **RAM:** 16GB+
-- **GPU:** NVIDIA with 8GB+ VRAM (RTX 3060+)
-- **Whisper:** Use "medium" or "large-v3" model
-- **LLM:** Use Llama3 8B or Mistral 7B
-
-### Optimal (power user)
-- **GPU:** RTX 4090 or similar (24GB VRAM)
-- **LLM:** Llama3 70B for best quality
-
----
-
-## Project Structure
-
-```
-video_analyzer/
-├── src/
-│   ├── __init__.py
-│   ├── main.py                 # Entry point
-│   ├── config.py               # Configuration
-│   │
-│   ├── downloaders/            # Video/content downloaders
-│   │   ├── __init__.py
-│   │   ├── base.py             # Base downloader class
-│   │   ├── ytdlp.py            # yt-dlp wrapper
-│   │   └── files.py            # Local file handling
-│   │
-│   ├── processors/             # Content processors
-│   │   ├── __init__.py
-│   │   ├── audio.py            # Audio extraction (ffmpeg)
-│   │   ├── transcriber.py      # Whisper transcription
-│   │   ├── documents.py        # PDF, Word, PPT
-│   │   └── ocr.py              # Tesseract OCR
-│   │
-│   ├── analyzers/              # AI analysis
-│   │   ├── __init__.py
-│   │   ├── summarizer.py       # Ollama summarization
-│   │   ├── extractor.py        # Key info extraction
-│   │   └── chunker.py          # Text chunking
-│   │
-│   ├── knowledge/              # Knowledge base
-│   │   ├── __init__.py
-│   │   ├── vectorstore.py      # ChromaDB
-│   │   ├── embeddings.py       # sentence-transformers
-│   │   └── search.py           # Semantic search
-│   │
-│   ├── mentor/                 # Virtual mentor
-│   │   ├── __init__.py
-│   │   ├── rag.py              # RAG pipeline
-│   │   ├── ollama_client.py    # Ollama integration
-│   │   └── prompts.py          # System prompts
-│   │
-│   └── ui/                     # User interfaces
-│       ├── __init__.py
-│       ├── cli.py              # Typer CLI
-│       └── web.py              # Gradio web app
-│
-├── data/                       # Data storage
-│   ├── downloads/              # Downloaded videos
-│   ├── audio/                  # Extracted audio
-│   ├── transcripts/            # Transcriptions
-│   ├── summaries/              # Summaries
-│   └── chromadb/               # Vector database
-│
-├── models/                     # Local model cache
-│   └── whisper/                # Whisper models
-│
-├── tests/
-├── requirements.txt
-├── install.sh                  # One-click setup script
-├── .cursorrules
-└── README.md
-```
-
----
-
-## Dependencies (requirements.txt)
-
-```
-# Core
-python-dotenv>=1.0.0
-typer[all]>=0.9.0
-rich>=13.0.0
-
-# Video/Audio
-yt-dlp>=2024.1.0
-ffmpeg-python>=0.2.0
-
-# Transcription
-faster-whisper>=1.0.0
-# or: openai-whisper>=20231117
-
-# Document Processing
-PyMuPDF>=1.23.0
-python-docx>=1.0.0
-python-pptx>=0.6.23
-pytesseract>=0.3.10
-
-# AI/ML
-sentence-transformers>=2.2.0
-chromadb>=0.4.0
-ollama>=0.1.0
-
-# Web UI
-gradio>=4.0.0
-
-# Utilities
-tqdm>=4.66.0
-pydantic>=2.0.0
-```
-
----
-
-## External Dependencies (System)
-
-```bash
-# Ubuntu/Debian
-sudo apt install ffmpeg tesseract-ocr
-
-# macOS
-brew install ffmpeg tesseract
-
-# Windows
-# Download ffmpeg and tesseract installers
-
-# Ollama (all platforms)
-curl -fsSL https://ollama.com/install.sh | sh
-ollama pull llama3        # or mistral, phi3
-```
-
----
-
-## Development Phases
-
-### Phase 1: Foundation (Week 1-2)
-- [ ] Project setup & dependencies
-- [ ] yt-dlp video downloader
-- [ ] ffmpeg audio extraction
-- [ ] faster-whisper transcription
-- [ ] Basic CLI with Typer
-
-### Phase 2: Processing Pipeline (Week 3-4)
-- [ ] PDF/Word/PPT processing
-- [ ] OCR for images
-- [ ] Text chunking strategy
-- [ ] SQLite metadata storage
-- [ ] Batch processing
-
-### Phase 3: Knowledge Base (Week 5-6)
-- [ ] sentence-transformers embeddings
-- [ ] ChromaDB integration
-- [ ] Semantic search
-- [ ] Hybrid search (semantic + keyword)
-- [ ] Source attribution
-
-### Phase 4: Virtual Mentor (Week 7-8)
-- [ ] Ollama integration
-- [ ] RAG implementation
-- [ ] Real estate prompts
-- [ ] Conversation memory
-- [ ] CLI chat interface
-
-### Phase 5: Polish & UI (Week 9-10)
-- [ ] Gradio web interface
-- [ ] Progress tracking
-- [ ] Export features
-- [ ] Error handling
-- [ ] Documentation
-
----
-
-## Real Estate Mentor - Special Features
-
-### Domain-Specific Prompts
-```python
-REAL_ESTATE_SYSTEM_PROMPT = """
-You are a knowledgeable real estate mentor with expertise from 
-the user's course materials. Help them with:
-- Deal analysis (cash flow, ROI, cap rates)
-- Negotiation strategies
-- Market analysis
-- Legal considerations
-- Financing options
-
-Always cite which video/document your advice comes from.
-"""
-```
-
-### Deal Analysis Helper
-- Input property details
-- Get relevant strategies from course content
-- Calculate key metrics
-- Risk assessment based on learned material
-
-### Study Features
-- Auto-generate flashcards
-- Create quizzes from content
-- Build glossary of terms
-- Track learning progress
-
----
-
-## CLI Commands
-
-```bash
-# Download video(s)
-video-analyzer download "https://youtube.com/watch?v=..."
-video-analyzer download --playlist "https://youtube.com/playlist?..."
-video-analyzer download --cookies cookies.txt "https://udemy.com/course/..."
-
-# Process content
-video-analyzer transcribe ./data/downloads/
-video-analyzer process ./documents/  # PDFs, Word, etc.
-
-# Build knowledge base
-video-analyzer index                  # Index all processed content
-video-analyzer search "what is cap rate"
-
-# Summarize
-video-analyzer summarize ./data/transcripts/video1.txt
-video-analyzer summarize --all        # Summarize everything
-
-# Chat with mentor
-video-analyzer chat                   # CLI chat
-video-analyzer ui                     # Launch web UI
-
-# Utilities
-video-analyzer status                 # Show processing status
-video-analyzer export                 # Export all notes
-```
-
----
-
-## Web UI Preview
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│  🎓 Real Estate Mentor                              [⚙️]    │
-├─────────────────────────────────────────────────────────────┤
-│                                                             │
-│  ┌─────────────────────────────────────────────────────┐   │
-│  │ 📚 Knowledge Base: 47 videos, 12 documents indexed  │   │
-│  └─────────────────────────────────────────────────────┘   │
-│                                                             │
-│  ┌─────────────────────────────────────────────────────┐   │
-│  │ You: How do I calculate cash-on-cash return?        │   │
-│  │                                                     │   │
-│  │ Mentor: Cash-on-cash return measures the annual     │   │
-│  │ pre-tax cash flow relative to the total cash        │   │
-│  │ invested. The formula is:                           │   │
-│  │                                                     │   │
-│  │ CoC Return = (Annual Cash Flow / Total Cash) × 100  │   │
-│  │                                                     │   │
-│  │ ���� Source: Module 3 - Investment Analysis (12:34)   │   │
-│  └─────────────────────────────────────────────────────┘   │
-│                                                             │
-│  [Type your question here...                    ] [Send]    │
-│                                                             │
-│  [📥 Add Content] [📊 Analyze Deal] [📝 Study Mode]        │
-│                                                             │
-└─────────────────────────────────────────────────────────────┘
-```
-
----
-
-## Cost Comparison
-
-| Approach | Monthly Cost | Our Approach |
-|----------|--------------|--------------|
-| OpenAI GPT-4 | $20-100+ | **$0** (Ollama) |
-| OpenAI Whisper API | $0.006/min | **$0** (local Whisper) |
-| Pinecone Vector DB | $70+ | **$0** (ChromaDB) |
-| Cloud transcription | $0.01-0.05/min | **$0** (local) |
-| **Total** | **$100+/month** | **$0** |
-
-**Only costs:** Electricity to run your computer 💡
-
----
-
-## Next Steps
-
-1. ✅ Plan complete - 100% free & open source
-2. **Ready to start coding!**
-
-Shall I begin with Phase 1?
-- Set up project structure
-- Install dependencies  
-- Build the video downloader

README.md

@@ -1,192 +1,14 @@
-# Video Analyzer 🎬
-
-**100% Free & Open Source** - No API costs, runs entirely on your machine.
-
-A powerful tool to download videos from multiple sources, transcribe to text, summarize content, and build a searchable knowledge base with an AI-powered virtual mentor.
-
-## 🎯 Use Case
-
-Turn online courses (like real estate training) into a personal AI mentor that can:
-- Answer questions about course content
-- Help analyze deals using learned strategies
-- Provide quick access to key concepts and definitions
-- **All running locally - your data stays private!**
-
-## 🆓 100% Free Stack
-
-| Component | Tool | Cost |
-|-----------|------|------|
-| Video Download | yt-dlp | Free |
-| Transcription | Whisper (local) | Free |
-| Document Processing | PyMuPDF, python-docx | Free |
-| OCR | Tesseract | Free |
-| Summarization | Ollama (Llama3/Mistral) | Free |
-| Vector Database | ChromaDB | Free |
-| Web UI | Gradio | Free |
-
-**Total monthly cost: $0** 💰
-
-## 📋 Features
-
-### Phase 1 ✅
-- **YouTube video downloading** with yt-dlp
-- **AI transcription** using local Whisper
-- **Audio extraction** with ffmpeg
-
-### Phase 2 ✅
-- **Direct file/folder import** - drop files and process
-- **PDF processing** with PyMuPDF
-- **Word/PowerPoint processing** 
-- **OCR for images** with Tesseract
-- **AI summarization** with Ollama (local LLM)
-- **Smart text chunking** for long documents
-
-### Coming Soon
-- **Phase 3:** Vector database + semantic search
-- **Phase 4:** Virtual mentor RAG chat
-- **Phase 5:** Web UI with Gradio
-
-## 💻 Requirements
-
-**Minimum:**
-- 8GB RAM (16GB recommended)
-- Any modern CPU
-- 20GB storage
-
-**Recommended (for faster processing):**
-- NVIDIA GPU with 8GB+ VRAM
-- 16GB+ RAM
-
-## 🚀 Quick Start
-
-### 1. Install Dependencies
-
-```bash
-# Clone and setup
-git clone <repo>
-cd video_analyzer
-
-# Install Python dependencies
-pip install -r requirements.txt
-```
-
-### 2. Install Ollama (for AI summaries)
-
-```bash
-# Install Ollama
-curl -fsSL https://ollama.com/install.sh | sh
-
-# Pull a model (choose one)
-ollama pull llama3      # Best quality (8B params)
-ollama pull mistral     # Good balance
-ollama pull phi3        # Fastest (3.8B params)
-
-# Start Ollama server
-ollama serve
-```
-
-### 3. Process Your Content
-
-```bash
-# Add local files (videos, PDFs, Word docs, etc.)
-./video-analyzer add /path/to/your/course/files
-
-# Process everything (transcribe videos, extract docs)
-./video-analyzer process-all
-
-# Generate AI summaries
-./video-analyzer summarize --all --type study_notes
-
-# Check status
-./video-analyzer status
-```
-
-## 📖 CLI Commands
-
-### Content Management
-```bash
-./video-analyzer add PATH              # Add files/folders
-./video-analyzer status                # Show statistics  
-./video-analyzer list-content          # List processed content
-```
-
-### Processing
-```bash
-./video-analyzer transcribe PATH       # Transcribe audio/video
-./video-analyzer process-docs [PATH]   # Process PDF/Word/PPT
-./video-analyzer process-images [PATH] # OCR images
-./video-analyzer process-all [PATH]    # Process everything
-```
-
-### YouTube (requires cookies)
-```bash
-./video-analyzer download URL --cookies cookies.txt
-./video-analyzer process URL --cookies cookies.txt
-```
-
-### AI Summarization
-```bash
-./video-analyzer summarize PATH        # Summarize one file
-./video-analyzer summarize --all       # Summarize all transcripts
-./video-analyzer summarize -t real_estate   # Real estate focus
-./video-analyzer summarize -t study_notes   # Study notes format
-```
-
-### Summary Types
-
-| Type | Description |
-|------|-------------|
-| `quick` | 2-3 paragraph overview |
-| `detailed` | Comprehensive summary with key points |
-| `study_notes` | Formatted notes with concepts, definitions, action items |
-| `real_estate` | Specialized for real estate content with deal analysis |
-
-## 🔧 Whisper Models
-
-| Model | Size | Speed | Quality | RAM |
-|-------|------|-------|---------|-----|
-| tiny | 39M | ⚡⚡⚡⚡ | Basic | 1GB |
-| base | 74M | ⚡⚡⚡ | Good | 1GB |
-| small | 244M | ⚡⚡ | Great | 2GB |
-| medium | 769M | ⚡ | Excellent | 5GB |
-| large-v3 | 1550M | 🐢 | Best | 10GB |
-
-## 📁 Project Structure
-
-```
-video_analyzer/
-├── src/
-│   ├── downloaders/     # yt-dlp, file handling
-│   ├── processors/      # Whisper, documents, OCR
-│   ├── analyzers/       # Ollama summarization, chunking
-│   ├── knowledge/       # Vector DB (Phase 3)
-│   ├── mentor/          # RAG chat (Phase 4)
-│   └── ui/              # CLI, web interface
-├── data/
-│   ├── downloads/       # Source files
-│   ├── audio/           # Extracted audio
-│   ├── transcripts/     # Text content
-│   └── summaries/       # AI summaries
-└── video-analyzer       # CLI script
-```
-
-## 📁 Supported Formats
-
-| Type | Formats |
-|------|---------|
-| Video | .mp4, .mkv, .avi, .mov, .webm, .flv |
-| Audio | .mp3, .wav, .m4a, .flac, .aac, .ogg |
-| Document | .pdf, .docx, .pptx, .txt, .md |
-| Image (OCR) | .png, .jpg, .jpeg, .gif, .bmp |
-
-## 🛠️ Development Status
-
-- [x] **Phase 1:** Video downloading + transcription
-- [x] **Phase 2:** Document processing + AI summarization  
-- [ ] **Phase 3:** Knowledge base + vector search
-- [ ] **Phase 4:** Virtual mentor + RAG chat
-- [ ] **Phase 5:** Web UI + polish
-
-## 📜 License
-
-MIT - Free for personal and commercial use
+---
+title: Video Analyzer
+emoji: "🎬"
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: "6.2.0"
+app_file: app.py
+pinned: false
+---
+
+# Video Analyzer
+
+A Gradio application.

VOICE_COMMANDS_PLAN.md

@@ -1,323 +0,0 @@
-# Voice Commands Plan - 100% Local & Private
-
-## BLUF (Bottom Line Up Front)
-
-**Add voice control to video_analyzer using Whisper (STT) + Piper (TTS) - both run entirely on your machine. No audio leaves your computer. No voice fingerprinting. No cloud APIs.**
-
----
-
-## ELI5 (Explain Like I'm 5)
-
-| What | How | Privacy |
-|------|-----|---------|
-| **You speak** | Microphone → Whisper (already in project!) | Audio never leaves your PC |
-| **App understands** | Whisper converts speech → text command | All processing is local |
-| **App responds** | Piper TTS converts text → speech | No voice profile created |
-| **Loop** | Wake word → listen → execute → respond | 100% offline capable |
-
-**Why this is private:**
-- Whisper runs locally - OpenAI never sees your voice
-- Piper TTS runs locally - no cloud synthesis
-- No internet required after initial setup
-- Your voice patterns stay on YOUR machine
-
----
-
-## Tech Stack (All Free & Local)
-
-| Component | Technology | Why This One |
-|-----------|------------|--------------|
-| **Speech-to-Text** | Whisper (faster-whisper) | Already in project! Fast, accurate, local |
-| **Text-to-Speech** | Piper TTS | Fast, natural voices, 100% local, tiny models |
-| **Wake Word** | Porcupine (free tier) or OpenWakeWord | Local detection, low CPU |
-| **Audio Capture** | sounddevice + numpy | Cross-platform, real-time |
-| **Command Parser** | Simple pattern matching → Ollama for complex | Start simple, add AI later |
-
-### Alternative TTS Options
-
-| TTS Engine | Quality | Speed | Size | Notes |
-|------------|---------|-------|------|-------|
-| **Piper** ⭐ | Great | ⚡⚡⚡ | 20-60MB | Best balance, recommended |
-| Coqui TTS | Excellent | ⚡⚡ | 200MB+ | More natural, heavier |
-| espeak-ng | Basic | ⚡⚡⚡⚡ | 5MB | Robotic but lightweight |
-| Bark | Amazing | ⚡ | 5GB+ | Too heavy for real-time |
-
----
-
-## Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────────┐
-│                    VOICE COMMAND SYSTEM (100% Local)                │
-├─────────────────────────────────────────────────────────────────────┤
-│                                                                     │
-│  ┌──────────────┐     ┌──────────────┐     ┌──────────────────┐   │
-│  │   Microphone │     │  Wake Word   │     │  Command Parser  │   │
-│  │   (sounddev) │ ──▶ │ (Porcupine)  │ ──▶ │  (pattern/Ollama)│   │
-│  └──────────────┘     └──────────────┘     └──────────────────┘   │
-│         │                                           │              │
-│         ▼                                           ▼              │
-│  ┌──────────────┐                          ┌──────────────────┐   │
-│  │   Whisper    │                          │  Execute Command │   │
-│  │   (STT)      │                          │  (existing CLI)  │   │
-│  │   LOCAL      │                          └──────────────────┘   │
-│  └──────────────┘                                   │              │
-│                                                     ▼              │
-│                                            ┌──────────────────┐   │
-│  ┌──────────────┐                          │   Piper TTS      │   │
-│  │   Speaker    │ ◀────────────────────────│   (local)        │   │
-│  └──────────────┘                          └──────────────────┘   │
-│                                                                     │
-│  🔒 ALL PROCESSING ON LOCAL MACHINE - NOTHING SENT TO CLOUD 🔒     │
-└─────────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## Voice Command Flow
-
-```
-1. IDLE STATE
-   └─▶ Listening for wake word ("Hey Analyzer" / "Computer")
-   
-2. WAKE WORD DETECTED
-   └─▶ Play acknowledgment sound
-   └─▶ Start recording user speech
-   
-3. USER SPEAKS COMMAND
-   └─▶ "Summarize my latest video"
-   └─▶ Silence detection → stop recording
-   
-4. SPEECH-TO-TEXT (Whisper)
-   └─▶ Audio → "summarize my latest video"
-   
-5. COMMAND PARSING
-   └─▶ Match to CLI command: `./video-analyzer summarize --latest`
-   └─▶ For complex queries → use Ollama to interpret
-   
-6. EXECUTE & RESPOND
-   └─▶ Run command
-   └─▶ Get result text
-   └─▶ Piper TTS → Speak result
-   
-7. RETURN TO IDLE
-```
-
----
-
-## Supported Voice Commands (Examples)
-
-| Voice Command | Maps To | Category |
-|---------------|---------|----------|
-| "What's my status" | `./video-analyzer status` | Info |
-| "Summarize latest video" | `./video-analyzer summarize --latest` | Processing |
-| "Add files from downloads" | `./video-analyzer add ~/Downloads` | Content |
-| "Process all videos" | `./video-analyzer process-all` | Processing |
-| "Search for cap rate" | `./video-analyzer search "cap rate"` | Knowledge |
-| "Start chat mode" | `./video-analyzer chat` | Interactive |
-| "What did I learn about negotiation" | RAG query via Ollama | Q&A |
-
----
-
-## Project Structure (New Files)
-
-```
-src/
-├── voice/                    # NEW MODULE
-│   ├── __init__.py
-│   ├── listener.py          # Microphone capture + wake word
-│   ├── stt.py               # Whisper wrapper for real-time
-│   ├── tts.py               # Piper TTS wrapper
-│   ├── commands.py          # Command pattern matching
-│   └── assistant.py         # Main voice assistant loop
-│
-├── processors/
-│   └── transcriber.py       # Already exists - reuse for STT
-```
-
----
-
-## Implementation Phases
-
-### Phase 1: Basic TTS (Speak Responses) — 2-3 hours
-- [ ] Install Piper TTS
-- [ ] Create `src/voice/tts.py`
-- [ ] Add `--speak` flag to CLI commands
-- [ ] Test: `./video-analyzer status --speak`
-
-### Phase 2: Real-time STT (Hear Commands) — 3-4 hours
-- [ ] Install sounddevice for audio capture
-- [ ] Create `src/voice/stt.py` (wrap existing Whisper)
-- [ ] Implement silence detection (stop recording)
-- [ ] Test: record → transcribe → print
-
-### Phase 3: Command Parsing — 2-3 hours
-- [ ] Create `src/voice/commands.py`
-- [ ] Pattern matching for simple commands
-- [ ] Ollama fallback for complex/natural queries
-- [ ] Map voice → CLI commands
-
-### Phase 4: Wake Word Detection — 2-3 hours
-- [ ] Choose: Porcupine (easier) or OpenWakeWord (more private)
-- [ ] Create `src/voice/listener.py`
-- [ ] Continuous low-power listening
-- [ ] Wake → record → process cycle
-
-### Phase 5: Voice Assistant Loop — 2-3 hours
-- [ ] Create `src/voice/assistant.py`
-- [ ] Full loop: wake → listen → parse → execute → speak
-- [ ] Add `./video-analyzer voice` command
-- [ ] Handle errors gracefully with voice feedback
-
-### Phase 6: Polish — 2-3 hours
-- [ ] Acknowledgment sounds (beeps/chimes)
-- [ ] Voice feedback for long operations ("Processing, please wait...")
-- [ ] Configurable wake word
-- [ ] Voice selection for TTS
-
----
-
-## Dependencies to Add
-
-```txt
-# Voice Commands - requirements.txt additions
-
-# Audio capture
-sounddevice>=0.4.6
-numpy>=1.24.0
-
-# Text-to-Speech (local)
-piper-tts>=1.2.0
-# Alternative: TTS>=0.22.0  # Coqui TTS
-
-# Wake Word Detection (choose one)
-pvporcupine>=3.0.0        # Easier setup, free tier
-# openwakeword>=0.5.0     # Fully open source
-
-# Voice Activity Detection
-webrtcvad>=2.0.10
-```
-
----
-
-## System Dependencies
-
-```bash
-# Ubuntu/Debian
-sudo apt install portaudio19-dev python3-pyaudio
-
-# For Piper TTS voices (download once)
-mkdir -p ~/.local/share/piper
-cd ~/.local/share/piper
-wget https://github.com/rhasspy/piper/releases/download/v1.2.0/voice-en_US-lessac-medium.onnx.json
-wget https://github.com/rhasspy/piper/releases/download/v1.2.0/voice-en_US-lessac-medium.onnx
-```
-
----
-
-## Privacy Guarantees
-
-### What NEVER Leaves Your Machine
-- ❌ Raw audio recordings
-- ❌ Voice patterns/fingerprints
-- ❌ Transcribed text
-- ❌ Commands you speak
-- ❌ Any biometric data
-
-### What Stays 100% Local
-- ✅ Whisper model runs locally
-- ✅ Piper TTS runs locally
-- ✅ Wake word detection runs locally
-- ✅ All audio processing is local
-- ✅ Works completely offline after setup
-
-### Compared to Cloud Alternatives
-
-| Cloud Service | What They Collect | Our Approach |
-|---------------|-------------------|--------------|
-| Alexa/Siri | Voice recordings, patterns | Nothing - all local |
-| Google Assistant | Voice data, usage patterns | Nothing - all local |
-| OpenAI Whisper API | Audio sent to cloud | Local Whisper - never sent |
-| ElevenLabs | Voice for cloning | Local Piper - no upload |
-
----
-
-## Configuration Options
-
-```json
-// config/voice.json
-{
-  "wake_word": "hey analyzer",
-  "stt_model": "base",           // tiny/base/small/medium
-  "tts_voice": "en_US-lessac-medium",
-  "tts_speed": 1.0,
-  "silence_threshold": 0.5,      // seconds of silence to stop
-  "confirmation_sounds": true,
-  "speak_responses": true,
-  "max_listen_time": 30          // seconds
-}
-```
-
----
-
-## Example Usage
-
-```bash
-# Start voice assistant mode
-./video-analyzer voice
-
-# One-shot voice command
-./video-analyzer voice --once
-
-# Status with spoken response  
-./video-analyzer status --speak
-
-# Process with voice feedback
-./video-analyzer process-all --speak
-```
-
-### Voice Session Example
-
-```
-[System]: Listening for "Hey Analyzer"...
-[You]:    "Hey Analyzer"
-[System]: *beep* "Yes?"
-[You]:    "What's my current status?"
-[System]: "You have 12 videos transcribed, 8 documents processed, 
-           and 47 items in your knowledge base. 3 videos are 
-           pending transcription."
-[System]: Listening for "Hey Analyzer"...
-[You]:    "Hey Analyzer"  
-[System]: *beep* "Yes?"
-[You]:    "Summarize the latest video about negotiation"
-[System]: "Working on it... The latest video covers 5 key 
-           negotiation tactics: anchoring, the flinch, 
-           bracketing, nibbling, and the walk-away..."
-```
-
----
-
-## Why This Approach?
-
-| Requirement | Solution |
-|-------------|----------|
-| **No voice collection** | All STT via local Whisper |
-| **No fingerprinting** | No cloud = no profile building |
-| **Works offline** | Everything runs locally |
-| **Fast response** | Piper TTS is <100ms latency |
-| **Natural voices** | Piper neural voices sound great |
-| **Low resources** | Base Whisper + Piper = ~500MB RAM |
-
----
-
-## Next Steps
-
-1. **Start with Phase 1** - Get TTS working first (instant gratification)
-2. **Then Phase 2** - Add STT (reuse existing Whisper code)
-3. **Phases 3-5** - Build up the full assistant
-4. **Phase 6** - Polish and customize
-
-Ready to start implementing? Just say the word! 🎤
-
-
-

app.py

@@ -0,0 +1,11 @@
+import gradio as gr
+
+demo = gr.Interface(
+    fn=lambda x: x,
+    inputs=gr.Textbox(label="Input"),
+    outputs=gr.Textbox(label="Output"),
+    title="Video Analyzer",
+)
+
+if __name__ == "__main__":
+    demo.launch()

data/summaries/sample_real_estate_summary.md

@@ -1 +0,0 @@
-Real estate investing success comes from: understanding your numbers, doing thorough due diligence, Negotiating, and avoiding common pitfalls. In the next module, we'll dive into deeper into strategies and how to structure deals for maximum returns. Real Estate Investment Fundamentals - Course Transcript is available in English and Spanish. For more information, visit the Real Estate Investing Course Transcripts website or click here for the English version. For the Spanish version, go to the Real estate Investment Course Transcript website or visit the Dutch version.

data/transcripts/sample_real_estate.txt

@@ -1,98 +0,0 @@
-Real Estate Investment Fundamentals - Course Transcript
-
-Welcome to Module 1: Understanding Real Estate Investment Basics
-
-Today we're going to cover the fundamental concepts every real estate investor needs to know. Whether you're just starting out or looking to expand your portfolio, these principles will guide your decision-making.
-
-CASH FLOW ANALYSIS
-
-Cash flow is the lifeblood of any real estate investment. Simply put, it's the money left over after you've collected rent and paid all expenses. Here's the basic formula:
-
-Monthly Cash Flow = Gross Rent - Operating Expenses - Mortgage Payment
-
-Let's break this down with an example. Say you have a rental property that brings in $2,000 per month in rent. Your expenses include:
-- Property taxes: $200/month
-- Insurance: $100/month  
-- Maintenance reserve: $150/month
-- Property management: $160/month (8% of rent)
-- Vacancy allowance: $100/month (5%)
-
-Total operating expenses: $710/month
-Mortgage payment: $900/month
-
-Cash flow = $2,000 - $710 - $900 = $390/month positive cash flow
-
-This is a healthy cash-flowing property!
-
-CAP RATE (CAPITALIZATION RATE)
-
-Cap rate helps you compare properties and determine value. It's calculated as:
-
-Cap Rate = Net Operating Income (NOI) / Property Value
-
-NOI is your annual income minus operating expenses (not including mortgage). Using our example:
-- Annual gross rent: $24,000
-- Annual operating expenses: $8,520
-- NOI: $15,480
-
-If the property is worth $200,000:
-Cap Rate = $15,480 / $200,000 = 7.74%
-
-Generally, higher cap rates mean higher returns but often come with more risk. Markets like New York might have 4% cap rates while smaller cities might offer 8-10%.
-
-CASH-ON-CASH RETURN
-
-This metric tells you how hard your actual invested cash is working:
-
-Cash-on-Cash Return = Annual Cash Flow / Total Cash Invested
-
-If you put $50,000 down on our example property:
-- Annual cash flow: $390 x 12 = $4,680
-- Cash-on-cash return: $4,680 / $50,000 = 9.36%
-
-That means you're earning 9.36% on your actual cash investment - much better than a savings account!
-
-THE 1% RULE
-
-A quick screening tool: the monthly rent should be at least 1% of the purchase price. For a $200,000 property, you'd want at least $2,000/month in rent.
-
-Our example property meets this rule: $2,000 / $200,000 = 1%
-
-NEGOTIATION STRATEGIES
-
-When making offers:
-1. Always start below asking price - leave room to negotiate
-2. Use inspection findings as leverage
-3. Ask for seller concessions on closing costs
-4. Be prepared to walk away - this is your strongest tool
-5. Build rapport with the seller when possible
-
-DUE DILIGENCE CHECKLIST
-
-Before closing, verify:
-- Rent rolls and actual income
-- All operating expenses with documentation  
-- Property condition (get professional inspection)
-- Comparable sales in the area
-- Zoning and any restrictions
-- Title search for liens or encumbrances
-
-COMMON MISTAKES TO AVOID
-
-1. Overestimating rental income
-2. Underestimating repairs and maintenance
-3. Not accounting for vacancy
-4. Skipping proper inspections
-5. Emotional decision-making
-6. Over-leveraging (too much debt)
-
-SUMMARY
-
-Real estate investing success comes from:
-- Understanding your numbers (cash flow, cap rate, CoC return)
-- Doing thorough due diligence
-- Negotiating effectively
-- Avoiding common pitfalls
-- Building for long-term wealth
-
-In the next module, we'll dive deeper into financing strategies and how to structure deals for maximum returns.

hf_space/README.md

@@ -1,39 +0,0 @@
----
-title: Real Estate Mentor
-emoji: 🏠
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 4.44.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-# 🏠 Real Estate Mentor
-
-Your AI-powered course assistant for real estate investing education.
-
-## Features
-
-- **🔍 Semantic Search** - Search your course content by meaning, not just keywords
-- **💬 Ask Questions** - Get answers based on your indexed materials  
-- **📤 Easy Upload** - Add transcripts and notes with one click
-- **💾 Persistent Storage** - Your data is saved between sessions
-
-## How to Use
-
-1. **Upload Content** - Go to the Upload tab and add your course transcripts
-2. **Search** - Use natural language to find relevant information
-3. **Ask** - Chat with your AI mentor about the content
-
-## Tech Stack
-
-- **Gradio** - Web interface
-- **ChromaDB** - Vector database for semantic search
-- **Sentence Transformers** - Text embeddings
-- **100% Free** - Runs entirely on HuggingFace Spaces
-
-## Privacy
-
-Your uploaded content is stored in this Space's persistent storage. No data is sent to external services.

hf_space/app.py

@@ -1,413 +0,0 @@
-"""
-Real Estate Mentor - HuggingFace Spaces App
-
-A semantic search and Q&A system for course content.
-Upload transcripts, search by meaning, and get answers.
-"""
-
-import os
-import sys
-from pathlib import Path
-
-# Add src to path for imports
-sys.path.insert(0, str(Path(__file__).parent))
-
-import gradio as gr
-
-# Set up persistent storage paths for HF Spaces
-DATA_DIR = Path(os.getenv("PERSISTENT_DIR", "/data" if os.path.exists("/data") else "./data"))
-CHROMA_DIR = DATA_DIR / "chromadb"
-TRANSCRIPTS_DIR = DATA_DIR / "transcripts"
-
-# Ensure directories exist
-for d in [CHROMA_DIR, TRANSCRIPTS_DIR]:
-    d.mkdir(parents=True, exist_ok=True)
-
-print(f"Data directory: {DATA_DIR}")
-print(f"ChromaDB directory: {CHROMA_DIR}")
-
-
-# ============== KNOWLEDGE BASE ==============
-
-class SimpleKnowledgeBase:
-    """Simplified knowledge base for HF Spaces."""
-    
-    def __init__(self):
-        self._client = None
-        self._collection = None
-        self._model = None
-    
-    def _init(self):
-        if self._client is not None:
-            return
-        
-        import chromadb
-        from chromadb.config import Settings
-        from sentence_transformers import SentenceTransformer
-        
-        # Initialize ChromaDB
-        self._client = chromadb.PersistentClient(
-            path=str(CHROMA_DIR),
-            settings=Settings(anonymized_telemetry=False)
-        )
-        self._collection = self._client.get_or_create_collection(
-            name="real_estate_mentor",
-            metadata={"hnsw:space": "cosine"}
-        )
-        
-        # Initialize embedding model
-        self._model = SentenceTransformer("all-MiniLM-L6-v2")
-        
-        print(f"Knowledge base initialized: {self._collection.count()} documents")
-    
-    def add_text(self, text: str, source: str, chunk_size: int = 500):
-        """Add text to the knowledge base in chunks."""
-        self._init()
-        
-        # Simple chunking by sentences/paragraphs
-        chunks = self._chunk_text(text, chunk_size)
-        
-        if not chunks:
-            return 0
-        
-        # Generate embeddings
-        embeddings = self._model.encode(chunks).tolist()
-        
-        # Generate IDs
-        import hashlib
-        ids = [
-            hashlib.md5(f"{source}:{i}:{c[:50]}".encode()).hexdigest()
-            for i, c in enumerate(chunks)
-        ]
-        
-        # Add to collection
-        self._collection.add(
-            ids=ids,
-            embeddings=embeddings,
-            documents=chunks,
-            metadatas=[{"source": source, "chunk_idx": i} for i in range(len(chunks))]
-        )
-        
-        return len(chunks)
-    
-    def _chunk_text(self, text: str, chunk_size: int = 500) -> list[str]:
-        """Split text into chunks."""
-        if len(text) <= chunk_size:
-            return [text] if text.strip() else []
-        
-        chunks = []
-        paragraphs = text.split("\n\n")
-        current_chunk = ""
-        
-        for para in paragraphs:
-            if len(current_chunk) + len(para) <= chunk_size:
-                current_chunk += para + "\n\n"
-            else:
-                if current_chunk.strip():
-                    chunks.append(current_chunk.strip())
-                current_chunk = para + "\n\n"
-        
-        if current_chunk.strip():
-            chunks.append(current_chunk.strip())
-        
-        return chunks
-    
-    def search(self, query: str, n_results: int = 5) -> list[dict]:
-        """Search the knowledge base."""
-        self._init()
-        
-        if self._collection.count() == 0:
-            return []
-        
-        # Generate query embedding
-        query_embedding = self._model.encode(query).tolist()
-        
-        # Search
-        results = self._collection.query(
-            query_embeddings=[query_embedding],
-            n_results=min(n_results, self._collection.count()),
-            include=["documents", "metadatas", "distances"]
-        )
-        
-        # Format results
-        output = []
-        if results["documents"] and results["documents"][0]:
-            for i, doc in enumerate(results["documents"][0]):
-                meta = results["metadatas"][0][i] if results["metadatas"] else {}
-                dist = results["distances"][0][i] if results["distances"] else 0
-                output.append({
-                    "text": doc,
-                    "source": meta.get("source", "unknown"),
-                    "score": 1 - dist  # Convert distance to similarity
-                })
-        
-        return output
-    
-    def count(self) -> int:
-        """Get document count."""
-        self._init()
-        return self._collection.count()
-    
-    def get_sources(self) -> list[str]:
-        """Get all sources."""
-        self._init()
-        results = self._collection.get(include=["metadatas"])
-        sources = set()
-        if results["metadatas"]:
-            for meta in results["metadatas"]:
-                if "source" in meta:
-                    sources.add(meta["source"])
-        return sorted(sources)
-    
-    def clear(self):
-        """Clear the knowledge base."""
-        self._init()
-        self._client.delete_collection("real_estate_mentor")
-        self._collection = self._client.create_collection(
-            name="real_estate_mentor",
-            metadata={"hnsw:space": "cosine"}
-        )
-
-
-# Global instance
-kb = SimpleKnowledgeBase()
-
-
-# ============== UI FUNCTIONS ==============
-
-def search_knowledge(query: str, n_results: int = 5) -> str:
-    """Search the knowledge base."""
-    if not query.strip():
-        return "⚠️ Please enter a search query."
-    
-    try:
-        results = kb.search(query, n_results=int(n_results))
-        
-        if not results:
-            return "📭 No results found. Upload some content first!"
-        
-        output = ["## 🔍 Search Results\n"]
-        for i, r in enumerate(results, 1):
-            source = Path(r["source"]).stem if r["source"] != "unknown" else "unknown"
-            score = r["score"] * 100
-            text = r["text"][:400] + "..." if len(r["text"]) > 400 else r["text"]
-            
-            output.append(f"### Result {i} — {score:.0f}% match")
-            output.append(f"📄 **Source:** {source}\n")
-            output.append(f"```\n{text}\n```\n")
-        
-        return "\n".join(output)
-    
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
-
-
-def upload_file(file, source_name: str) -> str:
-    """Process uploaded file."""
-    if file is None:
-        return "⚠️ Please select a file."
-    
-    try:
-        # Read content
-        with open(file.name, "r", encoding="utf-8", errors="ignore") as f:
-            content = f.read()
-        
-        if not content.strip():
-            return "⚠️ File is empty."
-        
-        # Use custom name or filename
-        name = source_name.strip() if source_name.strip() else Path(file.name).stem
-        
-        # Save locally
-        save_path = TRANSCRIPTS_DIR / f"{name}.txt"
-        save_path.write_text(content)
-        
-        # Index
-        chunks = kb.add_text(content, source=str(save_path))
-        
-        return f"""✅ **Successfully indexed!**
-
-- **Source:** {name}
-- **Chunks created:** {chunks}
-- **Characters:** {len(content):,}
-"""
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
-
-
-def upload_text(text: str, source_name: str) -> str:
-    """Process pasted text."""
-    if not text.strip():
-        return "⚠️ Please enter some text."
-    if not source_name.strip():
-        return "⚠️ Please provide a source name."
-    
-    try:
-        # Save locally
-        save_path = TRANSCRIPTS_DIR / f"{source_name.strip()}.txt"
-        save_path.write_text(text)
-        
-        # Index
-        chunks = kb.add_text(text, source=str(save_path))
-        
-        return f"""✅ **Successfully indexed!**
-
-- **Source:** {source_name}
-- **Chunks created:** {chunks}
-- **Characters:** {len(text):,}
-"""
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
-
-
-def get_status() -> str:
-    """Get knowledge base status."""
-    try:
-        count = kb.count()
-        sources = kb.get_sources()
-        
-        output = [f"## 📊 Knowledge Base Status\n"]
-        output.append(f"**Total chunks:** {count}")
-        output.append(f"**Sources:** {len(sources)}\n")
-        
-        if sources:
-            output.append("### 📁 Indexed Sources:")
-            for s in sources[:15]:
-                name = Path(s).stem
-                output.append(f"- {name}")
-            if len(sources) > 15:
-                output.append(f"- *...and {len(sources) - 15} more*")
-        else:
-            output.append("*No content indexed yet. Upload some files to get started!*")
-        
-        return "\n".join(output)
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
-
-
-def clear_all() -> str:
-    """Clear knowledge base."""
-    try:
-        kb.clear()
-        return "✅ Knowledge base cleared!"
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
-
-
-def chat_respond(message: str, history: list) -> tuple:
-    """Respond to chat message using RAG."""
-    if not message.strip():
-        return "", history
-    
-    try:
-        # Search for context
-        results = kb.search(message, n_results=3)
-        
-        if not results:
-            response = "I don't have any relevant information yet. Please upload some course content first! 📚"
-        else:
-            # Build response from context
-            sources = set()
-            context_parts = []
-            
-            for r in results:
-                source = Path(r["source"]).stem if r["source"] != "unknown" else "unknown"
-                sources.add(source)
-                context_parts.append(r["text"])
-            
-            context = "\n\n---\n\n".join(context_parts)
-            
-            response = f"""Based on your course materials:
-
-{context[:1500]}{"..." if len(context) > 1500 else ""}
-
----
-📚 *Sources: {", ".join(sources)}*"""
-        
-        history.append((message, response))
-        return "", history
-    
-    except Exception as e:
-        history.append((message, f"❌ Error: {str(e)}"))
-        return "", history
-
-
-# ============== BUILD APP ==============
-
-with gr.Blocks(
-    title="Real Estate Mentor",
-    theme=gr.themes.Soft()
-) as demo:
-    
-    gr.Markdown("""
-    # 🏠 Real Estate Mentor
-    
-    Your AI-powered course assistant. Upload transcripts, search semantically, and ask questions.
-    
-    ---
-    """)
-    
-    with gr.Tabs():
-        # Search Tab
-        with gr.TabItem("🔍 Search"):
-            with gr.Row():
-                with gr.Column(scale=4):
-                    search_input = gr.Textbox(
-                        label="Search Query",
-                        placeholder="e.g., How do I calculate cash-on-cash return?",
-                        lines=2
-                    )
-                with gr.Column(scale=1):
-                    n_results_slider = gr.Slider(1, 10, value=5, step=1, label="Results")
-            search_btn = gr.Button("🔍 Search", variant="primary")
-            search_output = gr.Markdown()
-            
-            search_btn.click(search_knowledge, [search_input, n_results_slider], search_output)
-            search_input.submit(search_knowledge, [search_input, n_results_slider], search_output)
-        
-        # Chat Tab
-        with gr.TabItem("💬 Ask"):
-            chatbot = gr.Chatbot(height=400, label="Chat")
-            chat_input = gr.Textbox(label="Your Question", placeholder="Ask about your course content...")
-            chat_btn = gr.Button("💬 Send", variant="primary")
-            
-            chat_btn.click(chat_respond, [chat_input, chatbot], [chat_input, chatbot])
-            chat_input.submit(chat_respond, [chat_input, chatbot], [chat_input, chatbot])
-        
-        # Upload Tab  
-        with gr.TabItem("📤 Upload"):
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### Upload File")
-                    file_input = gr.File(label="Select .txt or .md file", file_types=[".txt", ".md"])
-                    file_name = gr.Textbox(label="Custom Name (optional)", placeholder="e.g., Module 1")
-                    file_btn = gr.Button("📤 Upload", variant="primary")
-                    file_output = gr.Markdown()
-                    
-                    file_btn.click(upload_file, [file_input, file_name], file_output)
-                
-                with gr.Column():
-                    gr.Markdown("### Paste Text")
-                    text_input = gr.Textbox(label="Text Content", lines=8, placeholder="Paste transcript here...")
-                    text_name = gr.Textbox(label="Source Name", placeholder="e.g., Video 1 Notes")
-                    text_btn = gr.Button("📥 Index", variant="primary")
-                    text_output = gr.Markdown()
-                    
-                    text_btn.click(upload_text, [text_input, text_name], text_output)
-        
-        # Status Tab
-        with gr.TabItem("📊 Status"):
-            status_output = gr.Markdown()
-            with gr.Row():
-                refresh_btn = gr.Button("🔄 Refresh")
-                clear_btn = gr.Button("🗑️ Clear All", variant="stop")
-            
-            refresh_btn.click(get_status, outputs=status_output)
-            clear_btn.click(clear_all, outputs=status_output)
-            demo.load(get_status, outputs=status_output)
-    
-    gr.Markdown("---\n*Built with Gradio, ChromaDB & Sentence Transformers • 100% Free*")
-
-
-if __name__ == "__main__":
-    demo.launch()

hf_space/requirements.txt

@@ -1,5 +0,0 @@
-# HuggingFace Spaces Requirements
-gradio>=4.0.0
-chromadb>=0.4.0
-sentence-transformers>=2.2.0
-torch>=2.0.0

pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "video-analyzer"
+version = "0.1.0"
+description = "A Gradio application"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "gradio>=6.0.0",
+]

pytest.ini

@@ -1,9 +0,0 @@
-[pytest]
-testpaths = tests
-python_files = test_*.py
-python_classes = Test*
-python_functions = test_*
-addopts = -v --tb=short
-filterwarnings =
-    ignore::DeprecationWarning
-    ignore::UserWarning

requirements.txt

@@ -1,44 +0,0 @@
-# Video Analyzer - Dependencies
-# 100% Free & Open Source
-
-# Core
-python-dotenv>=1.0.0
-typer[all]>=0.9.0
-rich>=13.0.0
-pydantic>=2.0.0
-pydantic-settings>=2.0.0
-tqdm>=4.66.0
-
-# Video/Audio
-yt-dlp>=2024.1.0
-
-# Transcription
-faster-whisper>=1.0.0
-
-# Document Processing
-PyMuPDF>=1.23.0
-python-docx>=1.0.0
-python-pptx>=0.6.23
-
-# OCR (optional - requires system tesseract)
-pytesseract>=0.3.10
-Pillow>=10.0.0
-
-# AI/ML - Multiple options
-transformers>=4.36.0      # Hugging Face models
-torch>=2.0.0              # PyTorch backend
-# ollama>=0.1.0           # Optional: Ollama client
-
-# Testing
-pytest>=7.4.0
-pytest-cov>=4.1.0
-
-# Phase 3: Knowledge Base
-sentence-transformers>=2.2.0
-chromadb>=0.4.0
-
-# Phase 5: Web UI
-gradio>=4.0.0
-
-# Web UI (Phase 5)
-# gradio>=4.0.0

src/__init__.py

@@ -1,3 +0,0 @@
-"""Video Analyzer - Download, transcribe, and learn from video content."""
-
-__version__ = "0.1.0"

src/analyzers/__init__.py

@@ -1,26 +0,0 @@
-"""AI analyzers for summarization and extraction."""
-
-from .chunker import chunk_text, chunk_for_summarization, TextChunk
-from .summarizer import Summarizer, summarize_file, Summary, OllamaClient
-from .huggingface import (
-    HuggingFaceLocal, 
-    HuggingFaceAPI, 
-    HuggingFaceTextGen,
-    summarize_with_huggingface,
-    list_recommended_models
-)
-
-__all__ = [
-    "chunk_text",
-    "chunk_for_summarization", 
-    "TextChunk",
-    "Summarizer",
-    "summarize_file",
-    "Summary",
-    "OllamaClient",
-    "HuggingFaceLocal",
-    "HuggingFaceAPI",
-    "HuggingFaceTextGen",
-    "summarize_with_huggingface",
-    "list_recommended_models"
-]

src/analyzers/chunker.py

@@ -1,118 +0,0 @@
-"""Text chunking for processing long documents with LLMs."""
-
-from dataclasses import dataclass
-from typing import Optional
-
-
-@dataclass
-class TextChunk:
-    """A chunk of text with metadata."""
-    
-    text: str
-    index: int
-    start_char: int
-    end_char: int
-    
-    @property
-    def word_count(self) -> int:
-        return len(self.text.split())
-
-
-def chunk_text(
-    text: str,
-    chunk_size: int = 4000,
-    chunk_overlap: int = 200,
-    separator: str = "\n\n"
-) -> list[TextChunk]:
-    """Split text into overlapping chunks.
-    
-    Args:
-        text: Text to split
-        chunk_size: Maximum characters per chunk
-        chunk_overlap: Characters to overlap between chunks
-        separator: Preferred split point (paragraphs, sentences, etc.)
-        
-    Returns:
-        List of TextChunk objects
-    """
-    if len(text) <= chunk_size:
-        return [TextChunk(text=text, index=0, start_char=0, end_char=len(text))]
-    
-    chunks = []
-    start = 0
-    index = 0
-    
-    while start < len(text):
-        # Find end of chunk
-        end = start + chunk_size
-        
-        if end >= len(text):
-            # Last chunk
-            chunk_text = text[start:]
-            chunks.append(TextChunk(
-                text=chunk_text,
-                index=index,
-                start_char=start,
-                end_char=len(text)
-            ))
-            break
-        
-        # Try to find a good break point
-        # Look for separator near the end of the chunk
-        search_start = max(start + chunk_size - 500, start)
-        search_end = min(start + chunk_size + 200, len(text))
-        search_text = text[search_start:search_end]
-        
-        # Find last separator in search range
-        sep_pos = search_text.rfind(separator)
-        if sep_pos != -1:
-            end = search_start + sep_pos + len(separator)
-        else:
-            # Fall back to sentence end
-            for punct in [". ", "! ", "? ", "\n"]:
-                punct_pos = search_text.rfind(punct)
-                if punct_pos != -1:
-                    end = search_start + punct_pos + len(punct)
-                    break
-        
-        # Create chunk
-        chunk_text = text[start:end].strip()
-        if chunk_text:
-            chunks.append(TextChunk(
-                text=chunk_text,
-                index=index,
-                start_char=start,
-                end_char=end
-            ))
-            index += 1
-        
-        # Move start with overlap
-        start = end - chunk_overlap
-    
-    return chunks
-
-
-def chunk_for_summarization(
-    text: str,
-    max_tokens: int = 3000,
-    chars_per_token: float = 4.0
-) -> list[TextChunk]:
-    """Chunk text optimized for LLM summarization.
-    
-    Args:
-        text: Text to chunk
-        max_tokens: Maximum tokens per chunk (for LLM context)
-        chars_per_token: Approximate characters per token
-        
-    Returns:
-        List of TextChunk objects
-    """
-    chunk_size = int(max_tokens * chars_per_token)
-    overlap = int(chunk_size * 0.05)  # 5% overlap for context
-    
-    return chunk_text(text, chunk_size=chunk_size, chunk_overlap=overlap)
-
-
-def estimate_tokens(text: str, chars_per_token: float = 4.0) -> int:
-    """Estimate number of tokens in text."""
-    return int(len(text) / chars_per_token)

src/analyzers/huggingface.py

@@ -1,407 +0,0 @@
-"""AI summarization using Hugging Face (local models or API)."""
-
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Optional
-import os
-
-from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn
-
-from src.config import settings
-from src.analyzers.chunker import chunk_for_summarization, estimate_tokens
-
-console = Console()
-
-
-# Recommended models for different tasks
-RECOMMENDED_MODELS = {
-    "summarization": {
-        "small": "facebook/bart-large-cnn",        # Fast, good for news-style
-        "medium": "google/flan-t5-base",           # Balanced
-        "large": "google/flan-t5-large",           # Better quality
-        "best": "facebook/bart-large-xsum",        # Abstractive summaries
-    },
-    "text_generation": {
-        "small": "microsoft/phi-2",                # 2.7B, very fast
-        "medium": "mistralai/Mistral-7B-Instruct-v0.2",  # 7B, good quality
-        "large": "meta-llama/Llama-2-7b-chat-hf",  # Requires access
-    }
-}
-
-
-class HuggingFaceLocal:
-    """Run Hugging Face models locally."""
-    
-    def __init__(
-        self, 
-        model_name: str = "facebook/bart-large-cnn",
-        device: str = "auto"
-    ):
-        self.model_name = model_name
-        self.device = device
-        self._model = None
-        self._tokenizer = None
-    
-    def _load_model(self):
-        """Lazy load the model."""
-        if self._model is None:
-            console.print(f"[bold green]Loading model:[/] {self.model_name}")
-            console.print("[dim]This may take a few minutes on first run...[/]")
-            
-            try:
-                from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, pipeline
-                import torch
-            except ImportError:
-                raise ImportError(
-                    "Transformers not installed. Run:\n"
-                    "  pip install transformers torch"
-                )
-            
-            # Determine device
-            if self.device == "auto":
-                device = 0 if torch.cuda.is_available() else -1
-            else:
-                device = 0 if self.device == "cuda" else -1
-            
-            # Load tokenizer and model
-            self._tokenizer = AutoTokenizer.from_pretrained(self.model_name)
-            
-            # Use pipeline for easier inference
-            self._pipeline = pipeline(
-                "summarization",
-                model=self.model_name,
-                tokenizer=self._tokenizer,
-                device=device
-            )
-            
-            device_name = "GPU" if device >= 0 else "CPU"
-            console.print(f"[green]✓[/] Model loaded on {device_name}")
-    
-    def summarize(
-        self,
-        text: str,
-        max_length: int = 500,
-        min_length: int = 100
-    ) -> str:
-        """Summarize text using local model.
-        
-        Args:
-            text: Text to summarize
-            max_length: Maximum summary length in tokens
-            min_length: Minimum summary length in tokens
-            
-        Returns:
-            Summary text
-        """
-        self._load_model()
-        
-        # Handle long texts by chunking
-        tokens = estimate_tokens(text)
-        
-        if tokens > 1000:  # BART/T5 have ~1024 token limit
-            return self._summarize_chunks(text, max_length, min_length)
-        
-        result = self._pipeline(
-            text,
-            max_length=max_length,
-            min_length=min_length,
-            do_sample=False
-        )
-        
-        return result[0]["summary_text"]
-    
-    def _summarize_chunks(
-        self,
-        text: str,
-        max_length: int,
-        min_length: int
-    ) -> str:
-        """Summarize long text in chunks."""
-        chunks = chunk_for_summarization(text, max_tokens=800)
-        console.print(f"[bold blue]Processing {len(chunks)} chunks...[/]")
-        
-        chunk_summaries = []
-        
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            console=console
-        ) as progress:
-            task = progress.add_task("Summarizing...", total=len(chunks))
-            
-            for i, chunk in enumerate(chunks):
-                progress.update(task, description=f"Chunk {i+1}/{len(chunks)}")
-                
-                result = self._pipeline(
-                    chunk.text,
-                    max_length=max_length // len(chunks) + 50,
-                    min_length=min_length // len(chunks),
-                    do_sample=False
-                )
-                chunk_summaries.append(result[0]["summary_text"])
-                progress.advance(task)
-        
-        # Combine summaries
-        combined = " ".join(chunk_summaries)
-        
-        # If combined is still long, summarize again
-        if len(combined) > 2000:
-            console.print("[bold blue]Creating final summary...[/]")
-            result = self._pipeline(
-                combined,
-                max_length=max_length,
-                min_length=min_length,
-                do_sample=False
-            )
-            return result[0]["summary_text"]
-        
-        return combined
-
-
-class HuggingFaceAPI:
-    """Use Hugging Face Inference API (free tier available)."""
-    
-    def __init__(
-        self,
-        model_name: str = "facebook/bart-large-cnn",
-        api_key: Optional[str] = None
-    ):
-        self.model_name = model_name
-        # Check multiple sources for API key
-        self.api_key = (
-            api_key or 
-            os.getenv("HUGGINGFACE_API_KEY") or
-            os.getenv("VIDEO_ANALYZER_HUGGINGFACE_API_KEY")
-        )
-        
-        # Also try loading from settings
-        if not self.api_key:
-            try:
-                from src.config import settings
-                self.api_key = settings.huggingface_api_key
-            except:
-                pass
-        
-        self.api_url = f"https://router.huggingface.co/hf-inference/models/{model_name}"
-    
-    def _check_api_key(self):
-        if not self.api_key:
-            raise ValueError(
-                "Hugging Face API key not found.\n"
-                "Set it via:\n"
-                "  export HUGGINGFACE_API_KEY=your_key\n"
-                "Or get a free key at: https://huggingface.co/settings/tokens"
-            )
-    
-    def summarize(
-        self,
-        text: str,
-        max_length: int = 500,
-        min_length: int = 100
-    ) -> str:
-        """Summarize text using Hugging Face API.
-        
-        Args:
-            text: Text to summarize
-            max_length: Maximum summary length
-            min_length: Minimum summary length
-            
-        Returns:
-            Summary text
-        """
-        self._check_api_key()
-        
-        try:
-            import requests
-        except ImportError:
-            raise ImportError("requests not installed. Run: pip install requests")
-        
-        headers = {"Authorization": f"Bearer {self.api_key}"}
-        
-        # Handle long texts
-        tokens = estimate_tokens(text)
-        if tokens > 1000:
-            return self._summarize_chunks_api(text, max_length, min_length, headers)
-        
-        payload = {
-            "inputs": text,
-            "parameters": {
-                "max_length": max_length,
-                "min_length": min_length,
-                "do_sample": False
-            }
-        }
-        
-        with console.status("[bold green]Calling Hugging Face API..."):
-            response = requests.post(self.api_url, headers=headers, json=payload)
-        
-        if response.status_code != 200:
-            error = response.json().get("error", response.text)
-            raise Exception(f"API error: {error}")
-        
-        result = response.json()
-        
-        if isinstance(result, list) and len(result) > 0:
-            return result[0].get("summary_text", str(result))
-        
-        return str(result)
-    
-    def _summarize_chunks_api(
-        self,
-        text: str,
-        max_length: int,
-        min_length: int,
-        headers: dict
-    ) -> str:
-        """Summarize chunks via API."""
-        import requests
-        
-        chunks = chunk_for_summarization(text, max_tokens=800)
-        console.print(f"[bold blue]Processing {len(chunks)} chunks via API...[/]")
-        
-        chunk_summaries = []
-        
-        for i, chunk in enumerate(chunks):
-            console.print(f"[dim]Chunk {i+1}/{len(chunks)}...[/]")
-            
-            payload = {
-                "inputs": chunk.text,
-                "parameters": {
-                    "max_length": max_length // len(chunks) + 50,
-                    "min_length": min(30, min_length // len(chunks)),
-                    "do_sample": False
-                }
-            }
-            
-            response = requests.post(self.api_url, headers=headers, json=payload)
-            
-            if response.status_code == 200:
-                result = response.json()
-                if isinstance(result, list) and len(result) > 0:
-                    chunk_summaries.append(result[0].get("summary_text", ""))
-        
-        return " ".join(chunk_summaries)
-
-
-class HuggingFaceTextGen:
-    """Use Hugging Face for text generation (like Ollama alternative)."""
-    
-    def __init__(
-        self,
-        model_name: str = "microsoft/phi-2",
-        device: str = "auto"
-    ):
-        self.model_name = model_name
-        self.device = device
-        self._pipeline = None
-    
-    def _load_model(self):
-        """Lazy load the model."""
-        if self._pipeline is None:
-            console.print(f"[bold green]Loading model:[/] {self.model_name}")
-            console.print("[dim]This may download several GB on first run...[/]")
-            
-            try:
-                from transformers import pipeline
-                import torch
-            except ImportError:
-                raise ImportError(
-                    "Transformers not installed. Run:\n"
-                    "  pip install transformers torch accelerate"
-                )
-            
-            # Determine device
-            if self.device == "auto":
-                device = "cuda" if torch.cuda.is_available() else "cpu"
-            else:
-                device = self.device
-            
-            self._pipeline = pipeline(
-                "text-generation",
-                model=self.model_name,
-                device_map="auto" if device == "cuda" else None,
-                torch_dtype="auto"
-            )
-            
-            console.print(f"[green]✓[/] Model loaded on {device}")
-    
-    def generate(
-        self,
-        prompt: str,
-        max_new_tokens: int = 500,
-        temperature: float = 0.7
-    ) -> str:
-        """Generate text from prompt.
-        
-        Args:
-            prompt: Input prompt
-            max_new_tokens: Maximum tokens to generate
-            temperature: Creativity (0-1)
-            
-        Returns:
-            Generated text
-        """
-        self._load_model()
-        
-        result = self._pipeline(
-            prompt,
-            max_new_tokens=max_new_tokens,
-            temperature=temperature,
-            do_sample=temperature > 0,
-            pad_token_id=self._pipeline.tokenizer.eos_token_id
-        )
-        
-        generated = result[0]["generated_text"]
-        
-        # Remove the prompt from output
-        if generated.startswith(prompt):
-            generated = generated[len(prompt):].strip()
-        
-        return generated
-
-
-def summarize_with_huggingface(
-    text: str,
-    model: str = "facebook/bart-large-cnn",
-    use_api: bool = False,
-    api_key: Optional[str] = None,
-    max_length: int = 500
-) -> str:
-    """Convenience function to summarize with Hugging Face.
-    
-    Args:
-        text: Text to summarize
-        model: Model name
-        use_api: If True, use API instead of local
-        api_key: API key (if using API)
-        max_length: Maximum summary length
-        
-    Returns:
-        Summary text
-    """
-    if use_api:
-        client = HuggingFaceAPI(model, api_key)
-    else:
-        client = HuggingFaceLocal(model)
-    
-    return client.summarize(text, max_length=max_length)
-
-
-def list_recommended_models():
-    """Display recommended Hugging Face models."""
-    from rich.table import Table
-    
-    table = Table(title="Recommended Hugging Face Models")
-    table.add_column("Task", style="cyan")
-    table.add_column("Size", style="white")
-    table.add_column("Model", style="green")
-    table.add_column("Notes", style="dim")
-    
-    table.add_row("Summarization", "Small", "facebook/bart-large-cnn", "Fast, news-style")
-    table.add_row("Summarization", "Medium", "google/flan-t5-base", "Balanced")
-    table.add_row("Summarization", "Large", "google/flan-t5-large", "Better quality")
-    table.add_row("Text Gen", "Small", "microsoft/phi-2", "2.7B, very fast")
-    table.add_row("Text Gen", "Medium", "mistralai/Mistral-7B-Instruct-v0.2", "7B, good")
-    
-    console.print(table)

src/analyzers/summarizer.py

@@ -1,410 +0,0 @@
-"""AI-powered summarization using Ollama (local, free)."""
-
-import json
-import subprocess
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Optional
-
-from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn
-
-from src.config import settings
-from src.analyzers.chunker import chunk_for_summarization, estimate_tokens
-
-console = Console()
-
-
-@dataclass
-class Summary:
-    """A generated summary."""
-    
-    text: str
-    source_path: Optional[Path]
-    model: str
-    summary_type: str  # quick, detailed, study_notes
-    original_length: int
-    summary_length: int
-    
-    @property
-    def compression_ratio(self) -> float:
-        """How much the text was compressed."""
-        if self.original_length == 0:
-            return 0
-        return self.summary_length / self.original_length
-    
-    def save(self, output_path: Optional[Path] = None) -> Path:
-        """Save summary to file."""
-        if output_path is None:
-            stem = self.source_path.stem if self.source_path else "summary"
-            output_path = settings.summaries_dir / f"{stem}_{self.summary_type}.md"
-        
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        output_path.write_text(self.text)
-        return output_path
-
-
-# Prompts for different summary types
-PROMPTS = {
-    "quick": """Summarize the following text in 2-3 paragraphs. Focus on the main points and key takeaways.
-
-TEXT:
-{text}
-
-SUMMARY:""",
-    
-    "detailed": """Create a detailed summary of the following text. Include:
-- Main topics covered
-- Key points and concepts
-- Important details and examples
-- Actionable insights
-
-TEXT:
-{text}
-
-DETAILED SUMMARY:""",
-    
-    "study_notes": """Create comprehensive study notes from the following text. Format as:
-
-## Key Concepts
-- List main concepts with brief explanations
-
-## Important Points
-- Bullet points of critical information
-
-## Definitions
-- Any important terms defined
-
-## Action Items
-- Practical steps or strategies mentioned
-
-## Summary
-- Brief overall summary
-
-TEXT:
-{text}
-
-STUDY NOTES:""",
-    
-    "real_estate": """You are a real estate expert. Analyze the following content and extract:
-
-## Key Real Estate Concepts
-- Investment strategies mentioned
-- Market analysis techniques
-- Deal evaluation methods
-
-## Financial Metrics
-- ROI, Cap Rate, Cash-on-Cash calculations if mentioned
-- Financing strategies
-
-## Negotiation & Strategy
-- Negotiation tactics
-- Deal structuring advice
-
-## Action Items
-- Practical steps to take
-
-## Critical Warnings
-- Risks or pitfalls mentioned
-
-TEXT:
-{text}
-
-REAL ESTATE ANALYSIS:"""
-}
-
-
-class OllamaClient:
-    """Client for interacting with Ollama."""
-    
-    def __init__(self, model: str = "llama3"):
-        self.model = model
-        self._verified = False
-    
-    def is_available(self) -> bool:
-        """Check if Ollama is running."""
-        try:
-            result = subprocess.run(
-                ["ollama", "list"],
-                capture_output=True,
-                text=True,
-                timeout=5
-            )
-            return result.returncode == 0
-        except (subprocess.TimeoutExpired, FileNotFoundError):
-            return False
-    
-    def list_models(self) -> list[str]:
-        """List available Ollama models."""
-        try:
-            result = subprocess.run(
-                ["ollama", "list"],
-                capture_output=True,
-                text=True,
-                timeout=10
-            )
-            if result.returncode != 0:
-                return []
-            
-            models = []
-            for line in result.stdout.strip().split("\n")[1:]:  # Skip header
-                if line.strip():
-                    model_name = line.split()[0]
-                    models.append(model_name)
-            return models
-        except Exception:
-            return []
-    
-    def pull_model(self, model: Optional[str] = None) -> bool:
-        """Pull/download a model."""
-        model = model or self.model
-        console.print(f"[bold green]Pulling model:[/] {model}")
-        
-        try:
-            result = subprocess.run(
-                ["ollama", "pull", model],
-                capture_output=False,
-                timeout=600  # 10 minutes
-            )
-            return result.returncode == 0
-        except Exception as e:
-            console.print(f"[red]Error pulling model:[/] {e}")
-            return False
-    
-    def generate(
-        self,
-        prompt: str,
-        system: Optional[str] = None,
-        temperature: float = 0.7,
-        max_tokens: int = 2000
-    ) -> str:
-        """Generate text using Ollama.
-        
-        Args:
-            prompt: The prompt to send
-            system: Optional system message
-            temperature: Creativity (0-1)
-            max_tokens: Maximum response length
-            
-        Returns:
-            Generated text
-        """
-        # Build the request
-        request = {
-            "model": self.model,
-            "prompt": prompt,
-            "stream": False,
-            "options": {
-                "temperature": temperature,
-                "num_predict": max_tokens
-            }
-        }
-        
-        if system:
-            request["system"] = system
-        
-        try:
-            # Use ollama CLI with run command
-            full_prompt = prompt
-            if system:
-                full_prompt = f"System: {system}\n\n{prompt}"
-            
-            result = subprocess.run(
-                ["ollama", "run", self.model],
-                input=full_prompt,
-                capture_output=True,
-                text=True,
-                timeout=300  # 5 minutes
-            )
-            
-            if result.returncode != 0:
-                raise Exception(f"Ollama error: {result.stderr}")
-            
-            return result.stdout.strip()
-            
-        except subprocess.TimeoutExpired:
-            raise Exception("Ollama request timed out")
-        except FileNotFoundError:
-            raise Exception(
-                "Ollama not found. Install it:\n"
-                "  curl -fsSL https://ollama.com/install.sh | sh\n"
-                "  ollama pull llama3"
-            )
-
-
-class Summarizer:
-    """Summarize text using Ollama."""
-    
-    def __init__(self, model: str = "llama3"):
-        self.client = OllamaClient(model)
-        self.model = model
-    
-    def summarize(
-        self,
-        text: str,
-        summary_type: str = "detailed",
-        source_path: Optional[Path] = None
-    ) -> Summary:
-        """Summarize text using Ollama.
-        
-        Args:
-            text: Text to summarize
-            summary_type: Type of summary (quick, detailed, study_notes, real_estate)
-            source_path: Optional path to source file
-            
-        Returns:
-            Summary object
-        """
-        # Check Ollama availability
-        if not self.client.is_available():
-            raise Exception(
-                "Ollama is not running. Start it with:\n"
-                "  ollama serve\n"
-                "Or install: curl -fsSL https://ollama.com/install.sh | sh"
-            )
-        
-        # Check if model is available
-        models = self.client.list_models()
-        if self.model not in models and f"{self.model}:latest" not in models:
-            console.print(f"[yellow]Model {self.model} not found. Pulling...[/]")
-            self.client.pull_model()
-        
-        # Get prompt template
-        prompt_template = PROMPTS.get(summary_type, PROMPTS["detailed"])
-        
-        # Check if text needs chunking
-        tokens = estimate_tokens(text)
-        
-        if tokens > 3000:
-            # Process in chunks
-            console.print(f"[bold blue]Text is long ({tokens} tokens). Processing in chunks...[/]")
-            return self._summarize_chunks(text, summary_type, source_path, prompt_template)
-        else:
-            # Process directly
-            return self._summarize_single(text, summary_type, source_path, prompt_template)
-    
-    def _summarize_single(
-        self,
-        text: str,
-        summary_type: str,
-        source_path: Optional[Path],
-        prompt_template: str
-    ) -> Summary:
-        """Summarize a single chunk of text."""
-        prompt = prompt_template.format(text=text)
-        
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            console=console
-        ) as progress:
-            progress.add_task(f"Generating {summary_type} summary...", total=None)
-            
-            response = self.client.generate(prompt)
-        
-        console.print(f"[green]✓[/] Summary generated")
-        
-        return Summary(
-            text=response,
-            source_path=source_path,
-            model=self.model,
-            summary_type=summary_type,
-            original_length=len(text),
-            summary_length=len(response)
-        )
-    
-    def _summarize_chunks(
-        self,
-        text: str,
-        summary_type: str,
-        source_path: Optional[Path],
-        prompt_template: str
-    ) -> Summary:
-        """Summarize text in chunks, then combine."""
-        chunks = chunk_for_summarization(text)
-        console.print(f"[bold blue]Split into {len(chunks)} chunks[/]")
-        
-        chunk_summaries = []
-        
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            console=console
-        ) as progress:
-            task = progress.add_task("Processing chunks...", total=len(chunks))
-            
-            for i, chunk in enumerate(chunks):
-                progress.update(task, description=f"Processing chunk {i+1}/{len(chunks)}...")
-                
-                prompt = prompt_template.format(text=chunk.text)
-                response = self.client.generate(prompt)
-                chunk_summaries.append(response)
-                
-                progress.advance(task)
-        
-        # Combine chunk summaries
-        if len(chunk_summaries) > 1:
-            console.print("[bold blue]Combining chunk summaries...[/]")
-            
-            combined_text = "\n\n---\n\n".join(chunk_summaries)
-            
-            combine_prompt = f"""Combine these summaries into one coherent {summary_type} summary. 
-Remove redundancy and organize the information clearly.
-
-SUMMARIES:
-{combined_text}
-
-COMBINED SUMMARY:"""
-            
-            final_response = self.client.generate(combine_prompt)
-        else:
-            final_response = chunk_summaries[0]
-        
-        console.print(f"[green]✓[/] Summary generated")
-        
-        return Summary(
-            text=final_response,
-            source_path=source_path,
-            model=self.model,
-            summary_type=summary_type,
-            original_length=len(text),
-            summary_length=len(final_response)
-        )
-
-
-def summarize_file(
-    path: Path,
-    summary_type: str = "detailed",
-    model: str = "llama3",
-    output_dir: Optional[Path] = None
-) -> Summary:
-    """Summarize a transcript or document file.
-    
-    Args:
-        path: Path to text file
-        summary_type: Type of summary
-        model: Ollama model to use
-        output_dir: Output directory for summary
-        
-    Returns:
-        Summary object
-    """
-    path = Path(path)
-    output_dir = output_dir or settings.summaries_dir
-    
-    if not path.exists():
-        raise FileNotFoundError(f"File not found: {path}")
-    
-    console.print(f"[bold green]Summarizing:[/] {path.name}")
-    
-    text = path.read_text(encoding="utf-8", errors="ignore")
-    
-    summarizer = Summarizer(model=model)
-    summary = summarizer.summarize(text, summary_type=summary_type, source_path=path)
-    
-    # Save summary
-    output_path = output_dir / f"{path.stem}_{summary_type}.md"
-    summary.save(output_path)
-    console.print(f"[green]✓[/] Saved: {output_path}")
-    
-    return summary

src/config.py

@@ -1,50 +0,0 @@
-"""Configuration management for Video Analyzer."""
-
-from pathlib import Path
-from typing import Optional
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-
-class Settings(BaseSettings):
-    """Application settings."""
-    
-    # Paths
-    base_dir: Path = Path(__file__).parent.parent
-    data_dir: Path = base_dir / "data"
-    downloads_dir: Path = data_dir / "downloads"
-    audio_dir: Path = data_dir / "audio"
-    transcripts_dir: Path = data_dir / "transcripts"
-    summaries_dir: Path = data_dir / "summaries"
-    
-    # yt-dlp settings
-    video_format: str = "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best"
-    audio_format: str = "bestaudio[ext=m4a]/bestaudio/best"
-    
-    # Whisper settings
-    whisper_model: str = "base"  # tiny, base, small, medium, large-v3
-    whisper_device: str = "auto"  # auto, cpu, cuda
-    
-    # AI settings
-    ai_backend: str = "huggingface"  # ollama, huggingface, huggingface-api
-    huggingface_api_key: Optional[str] = None
-    ollama_model: str = "llama3"
-    huggingface_model: str = "facebook/bart-large-cnn"
-    
-    # Processing
-    max_concurrent_downloads: int = 3
-    
-    model_config = SettingsConfigDict(
-        env_prefix="VIDEO_ANALYZER_",
-        env_file=".env",
-        env_file_encoding="utf-8",
-        extra="ignore"  # Ignore extra env vars
-    )
-
-
-# Global settings instance
-settings = Settings()
-
-# Ensure directories exist
-for dir_path in [settings.downloads_dir, settings.audio_dir, 
-                 settings.transcripts_dir, settings.summaries_dir]:
-    dir_path.mkdir(parents=True, exist_ok=True)

src/downloaders/__init__.py

@@ -1,6 +0,0 @@
-"""Video downloaders and file handling."""
-
-from .youtube import YouTubeDownloader
-from .files import scan_files, import_files, FileInfo, get_file_type
-
-__all__ = ["YouTubeDownloader", "scan_files", "import_files", "FileInfo", "get_file_type"]

src/downloaders/files.py

@@ -1,177 +0,0 @@
-"""Direct file and folder processing support."""
-
-import shutil
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Optional
-
-from rich.console import Console
-from rich.table import Table
-
-from src.config import settings
-
-console = Console()
-
-
-@dataclass
-class FileInfo:
-    """Information about a local file."""
-    
-    path: Path
-    name: str
-    size: int
-    file_type: str  # video, audio, document, image
-    extension: str
-    
-    @property
-    def size_formatted(self) -> str:
-        """Return human-readable file size."""
-        if self.size >= 1024 * 1024 * 1024:
-            return f"{self.size / (1024**3):.1f} GB"
-        elif self.size >= 1024 * 1024:
-            return f"{self.size / (1024**2):.1f} MB"
-        elif self.size >= 1024:
-            return f"{self.size / 1024:.1f} KB"
-        return f"{self.size} B"
-
-
-# File type mappings
-VIDEO_EXTENSIONS = {".mp4", ".mkv", ".avi", ".mov", ".webm", ".flv", ".wmv", ".m4v"}
-AUDIO_EXTENSIONS = {".mp3", ".wav", ".m4a", ".flac", ".aac", ".ogg", ".wma"}
-DOCUMENT_EXTENSIONS = {".pdf", ".docx", ".doc", ".pptx", ".ppt", ".txt", ".md", ".rtf"}
-IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".tiff", ".webp"}
-
-ALL_SUPPORTED = VIDEO_EXTENSIONS | AUDIO_EXTENSIONS | DOCUMENT_EXTENSIONS | IMAGE_EXTENSIONS
-
-
-def get_file_type(path: Path) -> str:
-    """Determine file type from extension."""
-    ext = path.suffix.lower()
-    if ext in VIDEO_EXTENSIONS:
-        return "video"
-    elif ext in AUDIO_EXTENSIONS:
-        return "audio"
-    elif ext in DOCUMENT_EXTENSIONS:
-        return "document"
-    elif ext in IMAGE_EXTENSIONS:
-        return "image"
-    return "unknown"
-
-
-def scan_files(
-    path: Path,
-    recursive: bool = True,
-    file_types: Optional[list[str]] = None
-) -> list[FileInfo]:
-    """Scan a file or directory for supported files.
-    
-    Args:
-        path: File or directory path
-        recursive: If True, scan subdirectories
-        file_types: Filter by type - ['video', 'audio', 'document', 'image']
-        
-    Returns:
-        List of FileInfo objects
-    """
-    path = Path(path)
-    files = []
-    
-    if path.is_file():
-        # Single file
-        if path.suffix.lower() in ALL_SUPPORTED:
-            file_type = get_file_type(path)
-            if file_types is None or file_type in file_types:
-                files.append(FileInfo(
-                    path=path,
-                    name=path.name,
-                    size=path.stat().st_size,
-                    file_type=file_type,
-                    extension=path.suffix.lower()
-                ))
-    elif path.is_dir():
-        # Directory
-        pattern = "**/*" if recursive else "*"
-        for file_path in path.glob(pattern):
-            if file_path.is_file() and file_path.suffix.lower() in ALL_SUPPORTED:
-                file_type = get_file_type(file_path)
-                if file_types is None or file_type in file_types:
-                    files.append(FileInfo(
-                        path=file_path,
-                        name=file_path.name,
-                        size=file_path.stat().st_size,
-                        file_type=file_type,
-                        extension=file_path.suffix.lower()
-                    ))
-    
-    # Sort by name
-    files.sort(key=lambda f: f.name.lower())
-    return files
-
-
-def import_files(
-    source: Path,
-    dest_dir: Optional[Path] = None,
-    copy: bool = True,
-    recursive: bool = True
-) -> list[FileInfo]:
-    """Import files from a source location to the data directory.
-    
-    Args:
-        source: Source file or directory
-        dest_dir: Destination directory (default: data/downloads)
-        copy: If True, copy files. If False, move files.
-        recursive: If True, scan subdirectories
-        
-    Returns:
-        List of imported FileInfo objects
-    """
-    source = Path(source)
-    dest_dir = dest_dir or settings.downloads_dir
-    dest_dir.mkdir(parents=True, exist_ok=True)
-    
-    files = scan_files(source, recursive=recursive)
-    imported = []
-    
-    for file_info in files:
-        dest_path = dest_dir / file_info.name
-        
-        # Handle duplicates
-        if dest_path.exists():
-            stem = dest_path.stem
-            suffix = dest_path.suffix
-            counter = 1
-            while dest_path.exists():
-                dest_path = dest_dir / f"{stem}_{counter}{suffix}"
-                counter += 1
-        
-        # Copy or move
-        if copy:
-            shutil.copy2(file_info.path, dest_path)
-            console.print(f"[green]✓[/] Copied: {file_info.name}")
-        else:
-            shutil.move(file_info.path, dest_path)
-            console.print(f"[green]✓[/] Moved: {file_info.name}")
-        
-        imported.append(FileInfo(
-            path=dest_path,
-            name=dest_path.name,
-            size=file_info.size,
-            file_type=file_info.file_type,
-            extension=file_info.extension
-        ))
-    
-    return imported
-
-
-def list_supported_formats():
-    """Display all supported file formats."""
-    table = Table(title="Supported File Formats")
-    table.add_column("Type", style="cyan")
-    table.add_column("Extensions", style="white")
-    
-    table.add_row("Video", ", ".join(sorted(VIDEO_EXTENSIONS)))
-    table.add_row("Audio", ", ".join(sorted(AUDIO_EXTENSIONS)))
-    table.add_row("Document", ", ".join(sorted(DOCUMENT_EXTENSIONS)))
-    table.add_row("Image (OCR)", ", ".join(sorted(IMAGE_EXTENSIONS)))
-    
-    console.print(table)

src/downloaders/youtube.py

@@ -1,264 +0,0 @@
-"""YouTube video downloader using yt-dlp."""
-
-import json
-import subprocess
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Optional
-
-from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn
-
-from src.config import settings
-
-console = Console()
-
-# Add local bin paths
-import os
-os.environ["PATH"] = os.environ.get("PATH", "") + ":/home/ubuntu/.local/bin:/home/ubuntu/.deno/bin"
-
-
-@dataclass
-class VideoInfo:
-    """Information about a downloaded video."""
-    
-    id: str
-    title: str
-    description: str
-    duration: int  # seconds
-    uploader: str
-    upload_date: str
-    url: str
-    filepath: Optional[Path] = None
-    audio_filepath: Optional[Path] = None
-    subtitles: Optional[str] = None
-    chapters: list = field(default_factory=list)
-    
-    @property
-    def duration_formatted(self) -> str:
-        """Return duration in HH:MM:SS format."""
-        hours, remainder = divmod(self.duration, 3600)
-        minutes, seconds = divmod(remainder, 60)
-        if hours:
-            return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
-        return f"{minutes:02d}:{seconds:02d}"
-
-
-class YouTubeDownloader:
-    """Download videos from YouTube using yt-dlp."""
-    
-    def __init__(self, output_dir: Optional[Path] = None, cookies_file: Optional[Path] = None):
-        self.output_dir = output_dir or settings.downloads_dir
-        self.output_dir.mkdir(parents=True, exist_ok=True)
-        self.cookies_file = cookies_file  # Path to cookies.txt for authenticated downloads
-    
-    def get_info(self, url: str) -> VideoInfo:
-        """Get video information without downloading."""
-        cmd = [
-            "yt-dlp",
-            "--dump-json",
-            "--no-download",
-        ]
-        
-        # Add cookies if provided
-        if self.cookies_file and Path(self.cookies_file).exists():
-            cmd.extend(["--cookies", str(self.cookies_file)])
-        
-        cmd.append(url)
-        
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        if result.returncode != 0:
-            error_msg = result.stderr
-            if "Sign in to confirm you're not a bot" in error_msg:
-                raise Exception(
-                    "YouTube requires authentication. Please provide a cookies file:\n"
-                    "1. Install a browser extension to export cookies (e.g., 'Get cookies.txt LOCALLY')\n"
-                    "2. Export cookies from youtube.com\n"
-                    "3. Use --cookies path/to/cookies.txt"
-                )
-            raise Exception(f"Failed to get video info: {error_msg}")
-        
-        data = json.loads(result.stdout)
-        
-        return VideoInfo(
-            id=data.get("id", ""),
-            title=data.get("title", "Unknown"),
-            description=data.get("description", ""),
-            duration=data.get("duration", 0),
-            uploader=data.get("uploader", "Unknown"),
-            upload_date=data.get("upload_date", ""),
-            url=url,
-            chapters=data.get("chapters", [])
-        )
-    
-    def download_video(
-        self,
-        url: str,
-        audio_only: bool = False,
-        get_subtitles: bool = True,
-        quality: str = "best"
-    ) -> VideoInfo:
-        """Download a video from YouTube.
-        
-        Args:
-            url: YouTube video URL
-            audio_only: If True, download only audio (faster for transcription)
-            get_subtitles: If True, download auto-generated subtitles if available
-            quality: Video quality - 'best', '1080p', '720p', '480p', 'audio'
-            
-        Returns:
-            VideoInfo with filepath set
-        """
-        # Get video info first
-        with console.status("[bold green]Getting video info..."):
-            info = self.get_info(url)
-        
-        console.print(f"[bold blue]Title:[/] {info.title}")
-        console.print(f"[bold blue]Duration:[/] {info.duration_formatted}")
-        console.print(f"[bold blue]Uploader:[/] {info.uploader}")
-        
-        # Build output template
-        output_template = str(self.output_dir / "%(id)s.%(ext)s")
-        
-        # Build yt-dlp command
-        cmd = [
-            "yt-dlp",
-            "--output", output_template,
-            "--no-playlist",  # Download single video only
-            "--newline",  # Progress on new lines
-        ]
-        
-        # Add cookies if provided
-        if self.cookies_file and Path(self.cookies_file).exists():
-            cmd.extend(["--cookies", str(self.cookies_file)])
-        
-        # Format selection
-        if audio_only:
-            cmd.extend([
-                "-x",  # Extract audio
-                "--audio-format", "mp3",
-                "--audio-quality", "0",  # Best quality
-            ])
-        else:
-            if quality == "best":
-                cmd.extend(["-f", "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best"])
-            elif quality == "1080p":
-                cmd.extend(["-f", "bestvideo[height<=1080][ext=mp4]+bestaudio[ext=m4a]/best[height<=1080]"])
-            elif quality == "720p":
-                cmd.extend(["-f", "bestvideo[height<=720][ext=mp4]+bestaudio[ext=m4a]/best[height<=720]"])
-            elif quality == "480p":
-                cmd.extend(["-f", "bestvideo[height<=480][ext=mp4]+bestaudio[ext=m4a]/best[height<=480]"])
-        
-        # Subtitles
-        if get_subtitles:
-            cmd.extend([
-                "--write-auto-sub",
-                "--sub-lang", "en",
-                "--sub-format", "srt/vtt/best",
-                "--convert-subs", "srt",
-            ])
-        
-        cmd.append(url)
-        
-        # Download
-        console.print(f"\n[bold green]Downloading...[/]")
-        
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        
-        if result.returncode != 0:
-            console.print(f"[red]Error:[/] {result.stderr}")
-            raise Exception(f"Download failed: {result.stderr}")
-        
-        # Find the downloaded file
-        if audio_only:
-            filepath = self.output_dir / f"{info.id}.mp3"
-            info.audio_filepath = filepath
-        else:
-            # Try common extensions
-            for ext in ["mp4", "webm", "mkv"]:
-                filepath = self.output_dir / f"{info.id}.{ext}"
-                if filepath.exists():
-                    break
-            info.filepath = filepath
-        
-        # Check for subtitles
-        subtitle_path = self.output_dir / f"{info.id}.en.srt"
-        if subtitle_path.exists():
-            info.subtitles = subtitle_path.read_text()
-            console.print(f"[green]✓[/] Subtitles downloaded")
-        
-        console.print(f"[green]✓[/] Downloaded to: {filepath}")
-        
-        return info
-    
-    def download_playlist(
-        self,
-        url: str,
-        audio_only: bool = False,
-        max_videos: Optional[int] = None
-    ) -> list[VideoInfo]:
-        """Download all videos from a playlist.
-        
-        Args:
-            url: YouTube playlist URL
-            audio_only: If True, download only audio
-            max_videos: Maximum number of videos to download
-            
-        Returns:
-            List of VideoInfo objects
-        """
-        # Get playlist info
-        cmd = [
-            "yt-dlp",
-            "--dump-json",
-            "--flat-playlist",
-            url
-        ]
-        
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        if result.returncode != 0:
-            raise Exception(f"Failed to get playlist info: {result.stderr}")
-        
-        # Parse each video entry
-        videos = []
-        for line in result.stdout.strip().split("\n"):
-            if line:
-                data = json.loads(line)
-                video_url = f"https://www.youtube.com/watch?v={data['id']}"
-                videos.append(video_url)
-        
-        if max_videos:
-            videos = videos[:max_videos]
-        
-        console.print(f"[bold blue]Found {len(videos)} videos in playlist[/]")
-        
-        # Download each video
-        downloaded = []
-        for i, video_url in enumerate(videos, 1):
-            console.print(f"\n[bold]Downloading {i}/{len(videos)}[/]")
-            try:
-                info = self.download_video(video_url, audio_only=audio_only)
-                downloaded.append(info)
-            except Exception as e:
-                console.print(f"[red]Failed to download:[/] {e}")
-        
-        return downloaded
-
-
-def download_youtube(
-    url: str,
-    audio_only: bool = False,
-    output_dir: Optional[Path] = None
-) -> VideoInfo:
-    """Convenience function to download a YouTube video.
-    
-    Args:
-        url: YouTube video URL
-        audio_only: If True, download only audio
-        output_dir: Output directory (default: data/downloads)
-        
-    Returns:
-        VideoInfo with download details
-    """
-    downloader = YouTubeDownloader(output_dir)
-    return downloader.download_video(url, audio_only=audio_only)

src/knowledge/__init__.py

@@ -1,19 +0,0 @@
-"""Knowledge base with vector storage."""
-
-from .embeddings import EmbeddingModel, embed_text, embed_texts
-from .vectorstore import KnowledgeBase, SearchResult, get_knowledge_base, search
-from .indexer import index_text, index_file, index_directory, reindex_all
-
-__all__ = [
-    "EmbeddingModel",
-    "embed_text",
-    "embed_texts",
-    "KnowledgeBase",
-    "SearchResult",
-    "get_knowledge_base",
-    "search",
-    "index_text",
-    "index_file",
-    "index_directory",
-    "reindex_all",
-]

src/knowledge/embeddings.py

@@ -1,107 +0,0 @@
-"""Embedding generation using sentence-transformers (local, free)."""
-
-from typing import Optional
-import numpy as np
-
-from rich.console import Console
-
-console = Console()
-
-
-class EmbeddingModel:
-    """Generate embeddings using sentence-transformers."""
-    
-    # Recommended models (all free, run locally)
-    MODELS = {
-        "fast": "all-MiniLM-L6-v2",           # 384 dims, very fast
-        "balanced": "all-mpnet-base-v2",       # 768 dims, good quality
-        "multilingual": "paraphrase-multilingual-MiniLM-L12-v2",  # 384 dims
-    }
-    
-    def __init__(self, model_name: str = "all-MiniLM-L6-v2"):
-        """Initialize embedding model.
-        
-        Args:
-            model_name: Model name or key from MODELS dict
-        """
-        # Allow shorthand names
-        if model_name in self.MODELS:
-            model_name = self.MODELS[model_name]
-        
-        self.model_name = model_name
-        self._model = None
-    
-    def _load_model(self):
-        """Lazy load the model."""
-        if self._model is None:
-            console.print(f"[bold green]Loading embedding model:[/] {self.model_name}")
-            
-            try:
-                from sentence_transformers import SentenceTransformer
-            except ImportError:
-                raise ImportError(
-                    "sentence-transformers not installed. Run:\n"
-                    "  pip install sentence-transformers"
-                )
-            
-            self._model = SentenceTransformer(self.model_name)
-            console.print(f"[green]✓[/] Model loaded (dim={self._model.get_sentence_embedding_dimension()})")
-    
-    @property
-    def dimension(self) -> int:
-        """Get embedding dimension."""
-        self._load_model()
-        return self._model.get_sentence_embedding_dimension()
-    
-    def embed(self, text: str) -> list[float]:
-        """Generate embedding for a single text.
-        
-        Args:
-            text: Text to embed
-            
-        Returns:
-            List of floats (embedding vector)
-        """
-        self._load_model()
-        embedding = self._model.encode(text, convert_to_numpy=True)
-        return embedding.tolist()
-    
-    def embed_batch(self, texts: list[str], show_progress: bool = True) -> list[list[float]]:
-        """Generate embeddings for multiple texts.
-        
-        Args:
-            texts: List of texts to embed
-            show_progress: Show progress bar
-            
-        Returns:
-            List of embedding vectors
-        """
-        self._load_model()
-        embeddings = self._model.encode(
-            texts, 
-            convert_to_numpy=True,
-            show_progress_bar=show_progress
-        )
-        return embeddings.tolist()
-
-
-# Global instance for convenience
-_default_model: Optional[EmbeddingModel] = None
-
-
-def get_embedding_model(model_name: str = "all-MiniLM-L6-v2") -> EmbeddingModel:
-    """Get or create the default embedding model."""
-    global _default_model
-    if _default_model is None or _default_model.model_name != model_name:
-        _default_model = EmbeddingModel(model_name)
-    return _default_model
-
-
-def embed_text(text: str) -> list[float]:
-    """Convenience function to embed a single text."""
-    return get_embedding_model().embed(text)
-
-
-def embed_texts(texts: list[str]) -> list[list[float]]:
-    """Convenience function to embed multiple texts."""
-    return get_embedding_model().embed_batch(texts)

src/knowledge/indexer.py

@@ -1,151 +0,0 @@
-"""Index content into the knowledge base."""
-
-from pathlib import Path
-from typing import Optional
-
-from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn
-
-from src.config import settings
-from src.analyzers.chunker import chunk_for_summarization
-from src.knowledge.vectorstore import KnowledgeBase, get_knowledge_base
-
-console = Console()
-
-
-def index_text(
-    text: str,
-    source: str,
-    kb: Optional[KnowledgeBase] = None,
-    chunk_size: int = 1000
-) -> int:
-    """Index a text into the knowledge base.
-    
-    Args:
-        text: Text content to index
-        source: Source identifier
-        kb: Knowledge base (uses default if None)
-        chunk_size: Characters per chunk
-        
-    Returns:
-        Number of chunks indexed
-    """
-    kb = kb or get_knowledge_base()
-    
-    # Chunk the text
-    chunks = chunk_for_summarization(text, max_tokens=chunk_size // 4)
-    
-    if not chunks:
-        return 0
-    
-    # Extract just the text from chunks
-    texts = [c.text for c in chunks]
-    metadatas = [{"start_char": c.start_char, "end_char": c.end_char} for c in chunks]
-    
-    # Add to knowledge base
-    kb.add_texts(texts, source=source, metadatas=metadatas)
-    
-    return len(chunks)
-
-
-def index_file(
-    path: Path,
-    kb: Optional[KnowledgeBase] = None
-) -> int:
-    """Index a file into the knowledge base.
-    
-    Args:
-        path: Path to text file
-        kb: Knowledge base (uses default if None)
-        
-    Returns:
-        Number of chunks indexed
-    """
-    path = Path(path)
-    
-    if not path.exists():
-        console.print(f"[red]File not found:[/] {path}")
-        return 0
-    
-    text = path.read_text(encoding="utf-8", errors="ignore")
-    
-    if not text.strip():
-        console.print(f"[yellow]Empty file:[/] {path.name}")
-        return 0
-    
-    return index_text(text, source=str(path), kb=kb)
-
-
-def index_directory(
-    path: Optional[Path] = None,
-    kb: Optional[KnowledgeBase] = None,
-    extensions: list[str] = [".txt", ".md"]
-) -> dict:
-    """Index all text files in a directory.
-    
-    Args:
-        path: Directory path (defaults to transcripts_dir)
-        kb: Knowledge base
-        extensions: File extensions to index
-        
-    Returns:
-        Dict with stats {files: int, chunks: int}
-    """
-    path = path or settings.transcripts_dir
-    path = Path(path)
-    kb = kb or get_knowledge_base()
-    
-    # Find all text files
-    files = []
-    for ext in extensions:
-        files.extend(path.glob(f"*{ext}"))
-    
-    if not files:
-        console.print(f"[yellow]No files found in {path}[/]")
-        return {"files": 0, "chunks": 0}
-    
-    console.print(f"[bold blue]Indexing {len(files)} files...[/]")
-    
-    total_chunks = 0
-    indexed_files = 0
-    
-    for file_path in files:
-        try:
-            chunks = index_file(file_path, kb=kb)
-            if chunks > 0:
-                indexed_files += 1
-                total_chunks += chunks
-        except Exception as e:
-            console.print(f"[red]Error indexing {file_path.name}:[/] {e}")
-    
-    console.print(f"[green]✓[/] Indexed {indexed_files} files, {total_chunks} chunks")
-    
-    return {"files": indexed_files, "chunks": total_chunks}
-
-
-def reindex_all(kb: Optional[KnowledgeBase] = None) -> dict:
-    """Clear and reindex everything.
-    
-    Args:
-        kb: Knowledge base
-        
-    Returns:
-        Dict with stats
-    """
-    kb = kb or get_knowledge_base()
-    
-    console.print("[bold yellow]Clearing existing index...[/]")
-    kb.clear()
-    
-    # Index transcripts
-    console.print("\n[bold blue]Indexing transcripts...[/]")
-    transcript_stats = index_directory(settings.transcripts_dir, kb=kb)
-    
-    # Index summaries
-    console.print("\n[bold blue]Indexing summaries...[/]")
-    summary_stats = index_directory(settings.summaries_dir, kb=kb, extensions=[".md", ".txt"])
-    
-    return {
-        "files": transcript_stats["files"] + summary_stats["files"],
-        "chunks": transcript_stats["chunks"] + summary_stats["chunks"]
-    }

src/knowledge/vectorstore.py

@@ -1,316 +0,0 @@
-"""Vector store using ChromaDB (local, free, persistent)."""
-
-import hashlib
-import json
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Optional
-
-from rich.console import Console
-
-from src.config import settings
-
-console = Console()
-
-
-@dataclass
-class SearchResult:
-    """A search result from the knowledge base."""
-    
-    text: str
-    source: str
-    score: float  # Similarity score (higher = more similar)
-    metadata: dict
-    
-    @property
-    def source_name(self) -> str:
-        """Get just the filename from source path."""
-        return Path(self.source).stem if self.source else "unknown"
-
-
-class KnowledgeBase:
-    """Vector store for semantic search using ChromaDB."""
-    
-    def __init__(
-        self,
-        persist_dir: Optional[Path] = None,
-        collection_name: str = "video_analyzer"
-    ):
-        """Initialize knowledge base.
-        
-        Args:
-            persist_dir: Directory for persistent storage
-            collection_name: Name of the ChromaDB collection
-        """
-        self.persist_dir = persist_dir or (settings.data_dir / "chromadb")
-        self.collection_name = collection_name
-        self._client = None
-        self._collection = None
-        self._embedding_model = None
-    
-    def _init_db(self):
-        """Initialize ChromaDB client and collection."""
-        if self._client is None:
-            try:
-                import chromadb
-                from chromadb.config import Settings as ChromaSettings
-            except ImportError:
-                raise ImportError(
-                    "ChromaDB not installed. Run:\n"
-                    "  pip install chromadb"
-                )
-            
-            # Create persistent client
-            self.persist_dir.mkdir(parents=True, exist_ok=True)
-            
-            self._client = chromadb.PersistentClient(
-                path=str(self.persist_dir),
-                settings=ChromaSettings(anonymized_telemetry=False)
-            )
-            
-            # Get or create collection
-            self._collection = self._client.get_or_create_collection(
-                name=self.collection_name,
-                metadata={"description": "Video Analyzer Knowledge Base"}
-            )
-            
-            console.print(f"[green]✓[/] Knowledge base loaded: {self._collection.count()} documents")
-    
-    def _get_embedding_model(self):
-        """Get the embedding model."""
-        if self._embedding_model is None:
-            from src.knowledge.embeddings import EmbeddingModel
-            self._embedding_model = EmbeddingModel()
-        return self._embedding_model
-    
-    def _generate_id(self, text: str, source: str) -> str:
-        """Generate a unique ID for a document."""
-        content = f"{source}:{text[:100]}"
-        return hashlib.md5(content.encode()).hexdigest()
-    
-    def add_text(
-        self,
-        text: str,
-        source: str,
-        metadata: Optional[dict] = None
-    ) -> str:
-        """Add a single text to the knowledge base.
-        
-        Args:
-            text: Text content
-            source: Source file path or identifier
-            metadata: Additional metadata
-            
-        Returns:
-            Document ID
-        """
-        self._init_db()
-        
-        # Generate embedding
-        model = self._get_embedding_model()
-        embedding = model.embed(text)
-        
-        # Generate ID
-        doc_id = self._generate_id(text, source)
-        
-        # Prepare metadata
-        meta = metadata or {}
-        meta["source"] = source
-        meta["text_length"] = len(text)
-        
-        # Add to collection
-        self._collection.add(
-            ids=[doc_id],
-            embeddings=[embedding],
-            documents=[text],
-            metadatas=[meta]
-        )
-        
-        return doc_id
-    
-    def add_texts(
-        self,
-        texts: list[str],
-        source: str,
-        metadatas: Optional[list[dict]] = None,
-        show_progress: bool = True
-    ) -> list[str]:
-        """Add multiple texts to the knowledge base.
-        
-        Args:
-            texts: List of text content
-            source: Source file path
-            metadatas: List of metadata dicts
-            show_progress: Show progress bar
-            
-        Returns:
-            List of document IDs
-        """
-        self._init_db()
-        
-        if not texts:
-            return []
-        
-        console.print(f"[bold blue]Indexing {len(texts)} chunks from {Path(source).name}[/]")
-        
-        # Generate embeddings in batch
-        model = self._get_embedding_model()
-        embeddings = model.embed_batch(texts, show_progress=show_progress)
-        
-        # Generate IDs and prepare metadata
-        ids = []
-        metas = []
-        for i, text in enumerate(texts):
-            doc_id = self._generate_id(text, f"{source}:{i}")
-            ids.append(doc_id)
-            
-            meta = metadatas[i] if metadatas else {}
-            meta["source"] = source
-            meta["chunk_index"] = i
-            meta["text_length"] = len(text)
-            metas.append(meta)
-        
-        # Add to collection
-        self._collection.add(
-            ids=ids,
-            embeddings=embeddings,
-            documents=texts,
-            metadatas=metas
-        )
-        
-        console.print(f"[green]✓[/] Added {len(texts)} chunks to knowledge base")
-        
-        return ids
-    
-    def search(
-        self,
-        query: str,
-        n_results: int = 5,
-        filter_source: Optional[str] = None
-    ) -> list[SearchResult]:
-        """Search the knowledge base semantically.
-        
-        Args:
-            query: Search query
-            n_results: Number of results to return
-            filter_source: Filter by source file
-            
-        Returns:
-            List of SearchResult objects
-        """
-        self._init_db()
-        
-        # Generate query embedding
-        model = self._get_embedding_model()
-        query_embedding = model.embed(query)
-        
-        # Build filter
-        where_filter = None
-        if filter_source:
-            where_filter = {"source": filter_source}
-        
-        # Search
-        results = self._collection.query(
-            query_embeddings=[query_embedding],
-            n_results=n_results,
-            where=where_filter,
-            include=["documents", "metadatas", "distances"]
-        )
-        
-        # Convert to SearchResult objects
-        search_results = []
-        if results["documents"] and results["documents"][0]:
-            for i, doc in enumerate(results["documents"][0]):
-                # Convert distance to similarity score (1 - distance for cosine)
-                distance = results["distances"][0][i] if results["distances"] else 0
-                score = 1 - distance  # Higher = more similar
-                
-                metadata = results["metadatas"][0][i] if results["metadatas"] else {}
-                source = metadata.pop("source", "unknown")
-                
-                search_results.append(SearchResult(
-                    text=doc,
-                    source=source,
-                    score=score,
-                    metadata=metadata
-                ))
-        
-        return search_results
-    
-    def count(self) -> int:
-        """Get total number of documents in the knowledge base."""
-        self._init_db()
-        return self._collection.count()
-    
-    def get_sources(self) -> list[str]:
-        """Get list of all sources in the knowledge base."""
-        self._init_db()
-        
-        # Get all metadata
-        results = self._collection.get(include=["metadatas"])
-        
-        sources = set()
-        if results["metadatas"]:
-            for meta in results["metadatas"]:
-                if "source" in meta:
-                    sources.add(meta["source"])
-        
-        return sorted(sources)
-    
-    def delete_source(self, source: str) -> int:
-        """Delete all documents from a specific source.
-        
-        Args:
-            source: Source path to delete
-            
-        Returns:
-            Number of documents deleted
-        """
-        self._init_db()
-        
-        # Get IDs for this source
-        results = self._collection.get(
-            where={"source": source},
-            include=["metadatas"]
-        )
-        
-        if not results["ids"]:
-            return 0
-        
-        # Delete
-        count = len(results["ids"])
-        self._collection.delete(ids=results["ids"])
-        
-        console.print(f"[green]✓[/] Deleted {count} chunks from {source}")
-        
-        return count
-    
-    def clear(self):
-        """Clear all documents from the knowledge base."""
-        self._init_db()
-        
-        # Delete and recreate collection
-        self._client.delete_collection(self.collection_name)
-        self._collection = self._client.create_collection(
-            name=self.collection_name,
-            metadata={"description": "Video Analyzer Knowledge Base"}
-        )
-        
-        console.print("[green]✓[/] Knowledge base cleared")
-
-
-# Convenience functions
-_default_kb: Optional[KnowledgeBase] = None
-
-
-def get_knowledge_base() -> KnowledgeBase:
-    """Get the default knowledge base instance."""
-    global _default_kb
-    if _default_kb is None:
-        _default_kb = KnowledgeBase()
-    return _default_kb
-
-
-def search(query: str, n_results: int = 5) -> list[SearchResult]:
-    """Search the knowledge base."""
-    return get_knowledge_base().search(query, n_results)

src/main.py

@@ -1,6 +0,0 @@
-"""Main entry point for Video Analyzer."""
-
-from src.ui.cli import app
-
-if __name__ == "__main__":
-    app()

src/mentor/__init__.py

@@ -1 +0,0 @@
-"""Virtual mentor with RAG (Phase 4+)."""

src/processors/__init__.py

@@ -1,18 +0,0 @@
-"""Content processors for audio, documents, and transcription."""
-
-from .audio import extract_audio
-from .transcriber import transcribe_audio, WhisperTranscriber
-from .documents import extract_document, process_documents, DocumentContent
-from .ocr import extract_text_from_image, process_images, OCRResult
-
-__all__ = [
-    "extract_audio",
-    "transcribe_audio", 
-    "WhisperTranscriber",
-    "extract_document",
-    "process_documents",
-    "DocumentContent",
-    "extract_text_from_image",
-    "process_images",
-    "OCRResult"
-]

src/processors/audio.py

@@ -1,83 +0,0 @@
-"""Audio extraction from video files using ffmpeg."""
-
-import subprocess
-from pathlib import Path
-from typing import Optional
-
-from rich.console import Console
-
-from src.config import settings
-
-console = Console()
-
-
-def extract_audio(
-    video_path: Path,
-    output_path: Optional[Path] = None,
-    audio_format: str = "mp3",
-    sample_rate: int = 16000,  # Whisper prefers 16kHz
-) -> Path:
-    """Extract audio from a video file using ffmpeg.
-    
-    Args:
-        video_path: Path to the video file
-        output_path: Output path for audio file (default: data/audio/<video_name>.mp3)
-        audio_format: Output audio format (mp3, wav, m4a)
-        sample_rate: Audio sample rate in Hz (16000 recommended for Whisper)
-        
-    Returns:
-        Path to the extracted audio file
-    """
-    video_path = Path(video_path)
-    
-    if not video_path.exists():
-        raise FileNotFoundError(f"Video not found: {video_path}")
-    
-    # Default output path
-    if output_path is None:
-        output_path = settings.audio_dir / f"{video_path.stem}.{audio_format}"
-    else:
-        output_path = Path(output_path)
-    
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    
-    console.print(f"[bold green]Extracting audio from:[/] {video_path.name}")
-    
-    # Build ffmpeg command
-    cmd = [
-        "ffmpeg",
-        "-i", str(video_path),
-        "-vn",  # No video
-        "-acodec", "libmp3lame" if audio_format == "mp3" else "pcm_s16le",
-        "-ar", str(sample_rate),  # Sample rate
-        "-ac", "1",  # Mono (better for speech recognition)
-        "-y",  # Overwrite output
-        str(output_path)
-    ]
-    
-    result = subprocess.run(cmd, capture_output=True, text=True)
-    
-    if result.returncode != 0:
-        raise Exception(f"Audio extraction failed: {result.stderr}")
-    
-    console.print(f"[green]✓[/] Audio extracted to: {output_path}")
-    
-    return output_path
-
-
-def get_audio_duration(audio_path: Path) -> float:
-    """Get the duration of an audio file in seconds."""
-    cmd = [
-        "ffprobe",
-        "-v", "error",
-        "-show_entries", "format=duration",
-        "-of", "default=noprint_wrappers=1:nokey=1",
-        str(audio_path)
-    ]
-    
-    result = subprocess.run(cmd, capture_output=True, text=True)
-    
-    if result.returncode != 0:
-        raise Exception(f"Failed to get audio duration: {result.stderr}")
-    
-    return float(result.stdout.strip())

src/processors/documents.py

@@ -1,278 +0,0 @@
-"""Document processing for PDF, Word, PowerPoint, and text files."""
-
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Optional
-
-from rich.console import Console
-
-from src.config import settings
-
-console = Console()
-
-
-@dataclass
-class DocumentContent:
-    """Extracted content from a document."""
-    
-    text: str
-    title: str
-    pages: int
-    source_path: Path
-    doc_type: str  # pdf, docx, pptx, txt, md
-    metadata: dict
-    
-    def save(self, output_path: Optional[Path] = None) -> Path:
-        """Save extracted text to file."""
-        if output_path is None:
-            output_path = settings.transcripts_dir / f"{self.source_path.stem}.txt"
-        
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        output_path.write_text(self.text)
-        return output_path
-
-
-def extract_pdf(path: Path) -> DocumentContent:
-    """Extract text from a PDF file.
-    
-    Args:
-        path: Path to PDF file
-        
-    Returns:
-        DocumentContent with extracted text
-    """
-    try:
-        import fitz  # PyMuPDF
-    except ImportError:
-        raise ImportError("PyMuPDF not installed. Run: pip install PyMuPDF")
-    
-    path = Path(path)
-    console.print(f"[bold green]Extracting PDF:[/] {path.name}")
-    
-    doc = fitz.open(path)
-    
-    text_parts = []
-    for page_num, page in enumerate(doc, 1):
-        text = page.get_text()
-        if text.strip():
-            text_parts.append(f"--- Page {page_num} ---\n{text}")
-    
-    full_text = "\n\n".join(text_parts)
-    
-    # Extract metadata
-    metadata = {
-        "author": doc.metadata.get("author", ""),
-        "title": doc.metadata.get("title", ""),
-        "subject": doc.metadata.get("subject", ""),
-        "creator": doc.metadata.get("creator", ""),
-    }
-    
-    title = metadata.get("title") or path.stem
-    
-    doc.close()
-    
-    console.print(f"[green]✓[/] Extracted {len(doc)} pages, {len(full_text)} characters")
-    
-    return DocumentContent(
-        text=full_text,
-        title=title,
-        pages=len(doc),
-        source_path=path,
-        doc_type="pdf",
-        metadata=metadata
-    )
-
-
-def extract_docx(path: Path) -> DocumentContent:
-    """Extract text from a Word document.
-    
-    Args:
-        path: Path to .docx file
-        
-    Returns:
-        DocumentContent with extracted text
-    """
-    try:
-        from docx import Document
-    except ImportError:
-        raise ImportError("python-docx not installed. Run: pip install python-docx")
-    
-    path = Path(path)
-    console.print(f"[bold green]Extracting Word doc:[/] {path.name}")
-    
-    doc = Document(path)
-    
-    text_parts = []
-    for para in doc.paragraphs:
-        if para.text.strip():
-            text_parts.append(para.text)
-    
-    # Also extract from tables
-    for table in doc.tables:
-        for row in table.rows:
-            row_text = " | ".join(cell.text.strip() for cell in row.cells if cell.text.strip())
-            if row_text:
-                text_parts.append(row_text)
-    
-    full_text = "\n\n".join(text_parts)
-    
-    # Extract metadata
-    metadata = {
-        "author": doc.core_properties.author or "",
-        "title": doc.core_properties.title or "",
-        "subject": doc.core_properties.subject or "",
-    }
-    
-    title = metadata.get("title") or path.stem
-    
-    console.print(f"[green]✓[/] Extracted {len(text_parts)} paragraphs, {len(full_text)} characters")
-    
-    return DocumentContent(
-        text=full_text,
-        title=title,
-        pages=1,  # Word docs don't have fixed pages
-        source_path=path,
-        doc_type="docx",
-        metadata=metadata
-    )
-
-
-def extract_pptx(path: Path) -> DocumentContent:
-    """Extract text from a PowerPoint presentation.
-    
-    Args:
-        path: Path to .pptx file
-        
-    Returns:
-        DocumentContent with extracted text
-    """
-    try:
-        from pptx import Presentation
-    except ImportError:
-        raise ImportError("python-pptx not installed. Run: pip install python-pptx")
-    
-    path = Path(path)
-    console.print(f"[bold green]Extracting PowerPoint:[/] {path.name}")
-    
-    prs = Presentation(path)
-    
-    text_parts = []
-    for slide_num, slide in enumerate(prs.slides, 1):
-        slide_text = [f"--- Slide {slide_num} ---"]
-        
-        for shape in slide.shapes:
-            if hasattr(shape, "text") and shape.text.strip():
-                slide_text.append(shape.text)
-        
-        if len(slide_text) > 1:  # Has content beyond header
-            text_parts.append("\n".join(slide_text))
-    
-    full_text = "\n\n".join(text_parts)
-    
-    console.print(f"[green]✓[/] Extracted {len(prs.slides)} slides, {len(full_text)} characters")
-    
-    return DocumentContent(
-        text=full_text,
-        title=path.stem,
-        pages=len(prs.slides),
-        source_path=path,
-        doc_type="pptx",
-        metadata={}
-    )
-
-
-def extract_text_file(path: Path) -> DocumentContent:
-    """Extract text from plain text or markdown files.
-    
-    Args:
-        path: Path to .txt or .md file
-        
-    Returns:
-        DocumentContent with text
-    """
-    path = Path(path)
-    console.print(f"[bold green]Reading text file:[/] {path.name}")
-    
-    text = path.read_text(encoding="utf-8", errors="ignore")
-    
-    console.print(f"[green]✓[/] Read {len(text)} characters")
-    
-    return DocumentContent(
-        text=text,
-        title=path.stem,
-        pages=1,
-        source_path=path,
-        doc_type=path.suffix.lstrip("."),
-        metadata={}
-    )
-
-
-def extract_document(path: Path) -> DocumentContent:
-    """Extract text from any supported document type.
-    
-    Args:
-        path: Path to document
-        
-    Returns:
-        DocumentContent with extracted text
-    """
-    path = Path(path)
-    ext = path.suffix.lower()
-    
-    if ext == ".pdf":
-        return extract_pdf(path)
-    elif ext in {".docx", ".doc"}:
-        return extract_docx(path)
-    elif ext in {".pptx", ".ppt"}:
-        return extract_pptx(path)
-    elif ext in {".txt", ".md", ".rtf"}:
-        return extract_text_file(path)
-    else:
-        raise ValueError(f"Unsupported document type: {ext}")
-
-
-def process_documents(
-    path: Path,
-    output_dir: Optional[Path] = None,
-    recursive: bool = True
-) -> list[DocumentContent]:
-    """Process all documents in a file or directory.
-    
-    Args:
-        path: File or directory path
-        output_dir: Output directory for extracted text
-        recursive: If True, scan subdirectories
-        
-    Returns:
-        List of DocumentContent objects
-    """
-    from src.downloaders.files import scan_files
-    
-    path = Path(path)
-    output_dir = output_dir or settings.transcripts_dir
-    
-    # Get document files
-    files = scan_files(path, recursive=recursive, file_types=["document"])
-    
-    if not files:
-        console.print("[yellow]No documents found[/]")
-        return []
-    
-    console.print(f"[bold blue]Found {len(files)} documents to process[/]")
-    
-    results = []
-    for file_info in files:
-        try:
-            content = extract_document(file_info.path)
-            
-            # Save extracted text
-            output_path = output_dir / f"{file_info.path.stem}.txt"
-            content.save(output_path)
-            console.print(f"[green]✓[/] Saved: {output_path.name}")
-            
-            results.append(content)
-            
-        except Exception as e:
-            console.print(f"[red]Error processing {file_info.name}:[/] {e}")
-    
-    return results

src/processors/ocr.py

@@ -1,133 +0,0 @@
-"""OCR (Optical Character Recognition) for images using Tesseract."""
-
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Optional
-
-from rich.console import Console
-
-from src.config import settings
-
-console = Console()
-
-
-@dataclass
-class OCRResult:
-    """Result of OCR processing."""
-    
-    text: str
-    source_path: Path
-    confidence: float  # 0-100
-    
-    def save(self, output_path: Optional[Path] = None) -> Path:
-        """Save extracted text to file."""
-        if output_path is None:
-            output_path = settings.transcripts_dir / f"{self.source_path.stem}_ocr.txt"
-        
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        output_path.write_text(self.text)
-        return output_path
-
-
-def extract_text_from_image(path: Path, language: str = "eng") -> OCRResult:
-    """Extract text from an image using Tesseract OCR.
-    
-    Args:
-        path: Path to image file
-        language: Tesseract language code (eng, spa, fra, deu, etc.)
-        
-    Returns:
-        OCRResult with extracted text
-    """
-    try:
-        import pytesseract
-        from PIL import Image
-    except ImportError:
-        raise ImportError(
-            "OCR dependencies not installed. Run:\n"
-            "  pip install pytesseract Pillow\n"
-            "  sudo apt install tesseract-ocr  # Linux\n"
-            "  brew install tesseract  # macOS"
-        )
-    
-    path = Path(path)
-    console.print(f"[bold green]OCR processing:[/] {path.name}")
-    
-    # Open and process image
-    image = Image.open(path)
-    
-    # Get OCR data with confidence scores
-    data = pytesseract.image_to_data(image, lang=language, output_type=pytesseract.Output.DICT)
-    
-    # Extract text and calculate average confidence
-    words = []
-    confidences = []
-    
-    for i, word in enumerate(data["text"]):
-        if word.strip():
-            words.append(word)
-            conf = data["conf"][i]
-            if conf > 0:  # -1 means no confidence data
-                confidences.append(conf)
-    
-    text = " ".join(words)
-    avg_confidence = sum(confidences) / len(confidences) if confidences else 0
-    
-    console.print(f"[green]✓[/] Extracted {len(words)} words, confidence: {avg_confidence:.1f}%")
-    
-    return OCRResult(
-        text=text,
-        source_path=path,
-        confidence=avg_confidence
-    )
-
-
-def process_images(
-    path: Path,
-    output_dir: Optional[Path] = None,
-    language: str = "eng",
-    recursive: bool = True
-) -> list[OCRResult]:
-    """Process all images in a file or directory with OCR.
-    
-    Args:
-        path: File or directory path
-        output_dir: Output directory for extracted text
-        language: Tesseract language code
-        recursive: If True, scan subdirectories
-        
-    Returns:
-        List of OCRResult objects
-    """
-    from src.downloaders.files import scan_files
-    
-    path = Path(path)
-    output_dir = output_dir or settings.transcripts_dir
-    
-    # Get image files
-    files = scan_files(path, recursive=recursive, file_types=["image"])
-    
-    if not files:
-        console.print("[yellow]No images found[/]")
-        return []
-    
-    console.print(f"[bold blue]Found {len(files)} images to process[/]")
-    
-    results = []
-    for file_info in files:
-        try:
-            result = extract_text_from_image(file_info.path, language=language)
-            
-            if result.text.strip():
-                # Save extracted text
-                output_path = output_dir / f"{file_info.path.stem}_ocr.txt"
-                result.save(output_path)
-                console.print(f"[green]✓[/] Saved: {output_path.name}")
-                results.append(result)
-            else:
-                console.print(f"[yellow]No text found in {file_info.name}[/]")
-            
-        except Exception as e:
-            console.print(f"[red]Error processing {file_info.name}:[/] {e}")
-    
-    return results

src/processors/transcriber.py

@@ -1,243 +0,0 @@
-"""Audio transcription using Whisper (local, free)."""
-
-import json
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Optional
-
-from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn
-
-from src.config import settings
-
-console = Console()
-
-
-@dataclass
-class TranscriptSegment:
-    """A segment of transcribed text with timing."""
-    
-    start: float  # Start time in seconds
-    end: float    # End time in seconds
-    text: str     # Transcribed text
-    
-    @property
-    def start_formatted(self) -> str:
-        """Format start time as HH:MM:SS."""
-        return self._format_time(self.start)
-    
-    @property
-    def end_formatted(self) -> str:
-        """Format end time as HH:MM:SS."""
-        return self._format_time(self.end)
-    
-    def _format_time(self, seconds: float) -> str:
-        hours, remainder = divmod(int(seconds), 3600)
-        minutes, secs = divmod(remainder, 60)
-        return f"{hours:02d}:{minutes:02d}:{secs:02d}"
-
-
-@dataclass
-class Transcript:
-    """Complete transcript with segments and metadata."""
-    
-    text: str                          # Full transcript text
-    segments: list[TranscriptSegment]  # Timed segments
-    language: str                      # Detected language
-    duration: float                    # Audio duration in seconds
-    
-    def to_srt(self) -> str:
-        """Convert to SRT subtitle format."""
-        lines = []
-        for i, seg in enumerate(self.segments, 1):
-            start = self._format_srt_time(seg.start)
-            end = self._format_srt_time(seg.end)
-            lines.append(f"{i}")
-            lines.append(f"{start} --> {end}")
-            lines.append(seg.text.strip())
-            lines.append("")
-        return "\n".join(lines)
-    
-    def _format_srt_time(self, seconds: float) -> str:
-        hours, remainder = divmod(int(seconds), 3600)
-        minutes, secs = divmod(remainder, 60)
-        ms = int((seconds % 1) * 1000)
-        return f"{hours:02d}:{minutes:02d}:{secs:02d},{ms:03d}"
-    
-    def save(self, output_path: Path, format: str = "txt") -> Path:
-        """Save transcript to file.
-        
-        Args:
-            output_path: Output file path
-            format: 'txt', 'srt', or 'json'
-        """
-        output_path = Path(output_path)
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        
-        if format == "txt":
-            output_path.write_text(self.text)
-        elif format == "srt":
-            output_path.write_text(self.to_srt())
-        elif format == "json":
-            data = {
-                "text": self.text,
-                "language": self.language,
-                "duration": self.duration,
-                "segments": [
-                    {"start": s.start, "end": s.end, "text": s.text}
-                    for s in self.segments
-                ]
-            }
-            output_path.write_text(json.dumps(data, indent=2))
-        
-        return output_path
-
-
-class WhisperTranscriber:
-    """Transcribe audio using faster-whisper (local, free)."""
-    
-    def __init__(
-        self,
-        model_size: str = "base",
-        device: str = "auto",
-        compute_type: str = "auto"
-    ):
-        """Initialize the transcriber.
-        
-        Args:
-            model_size: Whisper model size - tiny, base, small, medium, large-v3
-            device: Device to use - 'auto', 'cpu', 'cuda'
-            compute_type: Computation type - 'auto', 'int8', 'float16', 'float32'
-        """
-        self.model_size = model_size
-        self.device = device
-        self.compute_type = compute_type
-        self._model = None
-    
-    def _load_model(self):
-        """Lazy load the Whisper model."""
-        if self._model is None:
-            console.print(f"[bold green]Loading Whisper model:[/] {self.model_size}")
-            
-            from faster_whisper import WhisperModel
-            
-            # Determine device and compute type
-            device = self.device
-            compute_type = self.compute_type
-            
-            if device == "auto":
-                try:
-                    import torch
-                    device = "cuda" if torch.cuda.is_available() else "cpu"
-                except ImportError:
-                    device = "cpu"
-            
-            if compute_type == "auto":
-                compute_type = "float16" if device == "cuda" else "int8"
-            
-            self._model = WhisperModel(
-                self.model_size,
-                device=device,
-                compute_type=compute_type
-            )
-            
-            console.print(f"[green]✓[/] Model loaded on {device}")
-    
-    def transcribe(
-        self,
-        audio_path: Path,
-        language: Optional[str] = None,
-    ) -> Transcript:
-        """Transcribe an audio file.
-        
-        Args:
-            audio_path: Path to audio file
-            language: Language code (e.g., 'en') or None for auto-detect
-            
-        Returns:
-            Transcript object with full text and segments
-        """
-        audio_path = Path(audio_path)
-        
-        if not audio_path.exists():
-            raise FileNotFoundError(f"Audio file not found: {audio_path}")
-        
-        self._load_model()
-        
-        console.print(f"[bold green]Transcribing:[/] {audio_path.name}")
-        
-        # Transcribe
-        segments_generator, info = self._model.transcribe(
-            str(audio_path),
-            language=language,
-            beam_size=5,
-            word_timestamps=True,
-            vad_filter=True,  # Filter out non-speech
-        )
-        
-        # Collect segments
-        segments = []
-        full_text_parts = []
-        
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            console=console
-        ) as progress:
-            task = progress.add_task("Processing segments...", total=None)
-            
-            for segment in segments_generator:
-                segments.append(TranscriptSegment(
-                    start=segment.start,
-                    end=segment.end,
-                    text=segment.text
-                ))
-                full_text_parts.append(segment.text)
-                progress.update(task, description=f"Processed {len(segments)} segments...")
-        
-        transcript = Transcript(
-            text=" ".join(full_text_parts).strip(),
-            segments=segments,
-            language=info.language,
-            duration=info.duration
-        )
-        
-        console.print(f"[green]✓[/] Transcription complete")
-        console.print(f"[bold blue]Language:[/] {info.language}")
-        console.print(f"[bold blue]Duration:[/] {info.duration:.1f}s")
-        console.print(f"[bold blue]Segments:[/] {len(segments)}")
-        
-        return transcript
-
-
-def transcribe_audio(
-    audio_path: Path,
-    model_size: str = "base",
-    output_dir: Optional[Path] = None,
-    save_formats: list[str] = ["txt", "json"]
-) -> Transcript:
-    """Convenience function to transcribe audio and save results.
-    
-    Args:
-        audio_path: Path to audio file
-        model_size: Whisper model size
-        output_dir: Output directory (default: data/transcripts)
-        save_formats: List of formats to save ('txt', 'srt', 'json')
-        
-    Returns:
-        Transcript object
-    """
-    audio_path = Path(audio_path)
-    output_dir = output_dir or settings.transcripts_dir
-    
-    # Transcribe
-    transcriber = WhisperTranscriber(model_size=model_size)
-    transcript = transcriber.transcribe(audio_path)
-    
-    # Save in requested formats
-    for fmt in save_formats:
-        output_path = output_dir / f"{audio_path.stem}.{fmt}"
-        transcript.save(output_path, format=fmt)
-        console.print(f"[green]✓[/] Saved: {output_path}")
-    
-    return transcript

src/ui/__init__.py

@@ -1 +0,0 @@
-"""User interfaces for Video Analyzer."""