Upload 21 files

.gitattributes

@@ -0,0 +1 @@
+bun.lockb filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,11 +1,180 @@
+
+# ScriptVoice - AI-Powered TTS Script Editor
+
+A powerful Gradio-based application for creating, editing, and managing text-to-speech scripts with AI enhancement capabilities.
+
+## 🎯 Features
+
+- **📝 Script Management**: Create, edit, and organize multiple scripts
+- **🔊 Text-to-Speech**: Generate high-quality audio from your scripts using gTTS
+- **📝 Notes System**: Add and manage notes for each script
+- **📷 OCR Integration**: Extract text from images using Tesseract OCR
+- **🤖 AI Enhancement**: Enhance scripts with different tones and styles (framework ready)
+- **📤 Export Options**: Export scripts as text files or audio files
+- **⚙️ Customizable Settings**: Adjust voice speed, volume, and accessibility options
+- **📊 Real-time Word Count**: Track script length as you type
+
+## 🚀 Quick Start
+
+### Local Development
+
+1. **Clone the repository**
+```bash
+git clone <your-repo-url>
+cd scriptvoice-gradio
+```
+
+2. **Install dependencies**
+```bash
+pip install -r requirements.txt
+```
+
+3. **Install Tesseract OCR** (for image text extraction)
+- **Ubuntu/Debian**: `sudo apt-get install tesseract-ocr`
+- **macOS**: `brew install tesseract`
+- **Windows**: Download from [GitHub releases](https://github.com/UB-Mannheim/tesseract/wiki)
+
+4. **Run the application**
+```bash
+python app.py
+```
+
+5. **Open your browser** and navigate to `http://localhost:7860`
+
+### HuggingFace Spaces Deployment
+
+This app is designed to run on HuggingFace Spaces. Simply:
+
+1. Create a new Space on [HuggingFace](https://huggingface.co/spaces)
+2. Upload `app.py`, `requirements.txt`, and this `README.md`
+3. Set the Space SDK to "Gradio"
+4. Your app will be automatically deployed!
+
+## 🎮 How to Use
+
+### Creating Your First Script
+
+1. **Create a New Project**: Enter a name in the "New Project Name" field and click "➕ Create Project"
+2. **Write Your Script**: Use the main editor to write your content
+3. **Add Notes**: Use the notes section for reminders, directions, or script metadata
+4. **Generate Audio**: Click "🔊 Play TTS" to hear your script read aloud
+5. **Save Your Work**: Click "💾 Save" to persist your changes
+
+### Advanced Features
+
+- **OCR Text Extraction**: Upload an image containing text, and the app will extract it for you
+- **Voice Customization**: Adjust speed and volume in the settings panel
+- **Export Options**: Download your scripts as text files or audio files
+- **AI Enhancement**: (Framework ready) Enhance your scripts with different tones
+
+### Keyboard Shortcuts
+
+- **Ctrl+S** (planned): Quick save
+- **Ctrl+P** (planned): Play TTS
+- **Ctrl+N** (planned): New project
+
+## 🛠️ Technical Architecture
+
+### Core Components
+
+- **Gradio Blocks**: Modern, responsive UI framework
+- **gTTS**: Google Text-to-Speech for audio generation
+- **Tesseract OCR**: Image text extraction
+- **JSON Storage**: Simple, portable project persistence
+- **Python 3.10+**: Modern Python features and type hints
+
+### File Structure
+
+```
+scriptvoice-gradio/
+├── app.py              # Main Gradio application
+├── requirements.txt    # Python dependencies
+├── README.md          # This file
+├── projects.json      # Auto-generated project storage
+└── temp/              # Auto-generated temp files
+```
+
+### Data Persistence
+
+Projects are stored in `projects.json` with the following structure:
+
+```json
+{
+  "projects": {
+    "1": {
+      "id": "1",
+      "name": "Project Name",
+      "content": "Script content...",
+      "notes": "Project notes...",
+      "created_at": "2024-01-01T00:00:00",
+      "word_count": 42
+    }
+  },
+  "settings": {
+    "dyslexic_mode": false,
+    "voice_speed": 1.0,
+    "voice_volume": 1.0
+  }
+}
+```
+
+## 🔮 Future Enhancements
+
+### Planned Features
+
+- **🤖 Full AI Integration**: Connect to OpenAI GPT-4 or HuggingFace models for script enhancement
+- **🎭 Voice Cloning**: Integrate with voice cloning services
+- **📊 Analytics**: Script performance metrics and reading time estimates
+- **🌐 Multi-language Support**: Support for multiple TTS languages
+- **☁️ Cloud Storage**: Integration with Google Drive, Dropbox, or AWS S3
+- **👥 Collaboration**: Multi-user editing and sharing capabilities
+
+### AI Enhancement Framework
+
+The app includes a ready-to-extend framework for AI script enhancement:
+
+```python
+def enhance_script_with_ai(text, enhancement_type, api_key):
+    """
+    Future implementation for AI script enhancement
+    - Connect to OpenAI API or HuggingFace Hub
+    - Apply different enhancement styles
+    - Return enhanced script content
+    """
+    pass
+```
+
+## 🏆 Hackathon Demo
+
+This project was built for **Track 3: Agentic Demo** with the following goals:
+
+- ✅ **Rapid Prototyping**: From TypeScript to Python/Gradio in record time
+- ✅ **AI-Ready Architecture**: Framework for intelligent script enhancement
+- ✅ **Production Deployment**: Ready for HuggingFace Spaces hosting
+- ✅ **User-Friendly Interface**: Notion-like editing experience for storytellers
+
+### Demo Script
+
+"Welcome to ScriptVoice - where your words come to life! This AI-powered editor lets you craft compelling scripts, generate professional voiceovers, and enhance your content with intelligent suggestions. Whether you're a content creator, educator, or storyteller, ScriptVoice transforms your text into engaging audio experiences."
+
+## 🤝 Contributing
+
+We welcome contributions! Areas where help is needed:
+
+- **AI Model Integration**: Connect OpenAI or HuggingFace models
+- **Voice Options**: Add more TTS providers and voice choices
+- **UI/UX Improvements**: Enhance the user interface and experience
+- **Performance Optimization**: Improve app speed and responsiveness
+- **Testing**: Add comprehensive test coverage
+
+## 📄 License
+
+MIT License - see LICENSE file for details.
+
+## 🏷️ Tags
+
+`#gradio` `#text-to-speech` `#ai` `#python` `#huggingface` `#agent-demo-track` `#tts` `#script-editor` `#voice-generation`
+
 ---
-title: Script Scribe
-emoji: 🖼
-colorFrom: purple
-colorTo: red
-sdk: gradio
-sdk_version: 5.33.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
+
+**Built with ❤️ using Gradio and deployed on HuggingFace Spaces**

README_PYTHON.md

@@ -0,0 +1,70 @@
+
+# ScriptVoice - Pure Python Gradio Application
+
+## 🎯 Quick Start
+
+1. **Install Dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. **Run the Application**
+   ```bash
+   python main.py
+   ```
+   or
+   ```bash
+   python run.py
+   ```
+
+3. **Access the Application**
+   Open your browser to: http://localhost:7860
+
+## 📦 Dependencies
+
+This application uses the following Python packages:
+- `gradio>=4.0.0` - Web interface framework
+- `gtts>=2.3.0` - Text-to-speech
+- `pytesseract>=0.3.10` - OCR text extraction
+- `Pillow>=10.0.0` - Image processing
+- `langchain>=0.1.0` - LLM framework
+- `sentence-transformers>=2.2.0` - Text embeddings
+- `faiss-cpu>=1.7.0` - Vector database
+- `langchain-openai>=0.1.0` - OpenAI integration
+- `tiktoken>=0.5.0` - Text tokenization
+
+## 🌟 Features
+
+### Scripts Tab
+- Project management and script editing
+- Text-to-speech generation
+- OCR text extraction from images
+- AI script enhancement
+- Export functionality
+
+### Story Intelligence Tab
+- Knowledge Assistant with command processing
+- Context-aware AI tools
+- Character and story management
+- World building elements
+- RAG-powered search and analysis
+
+## 🔧 Configuration
+
+- All data is stored in local JSON files
+- No external database required
+- Gradio handles the web interface automatically
+
+## 🚀 Deployment
+
+The application is ready for deployment on platforms that support Python:
+- Hugging Face Spaces
+- Railway
+- Render
+- Heroku
+- Any Python hosting service
+
+For production deployment, make sure to:
+1. Set appropriate server configurations
+2. Configure environment variables if needed
+3. Ensure all dependencies are installed

audio_services.py

@@ -0,0 +1,24 @@
+
+"""Audio and TTS services for ScriptVoice."""
+
+import tempfile
+from gtts import gTTS
+from typing import Tuple, Optional
+
+
+def generate_tts(text: str, speed: float = 1.0) -> Tuple[Optional[str], str]:
+    """Generate TTS audio from text."""
+    if not text.strip():
+        return None, '<div class="status-error">❌ Please enter some text to convert to speech</div>'
+    
+    try:
+        # Create a temporary file for the audio
+        tts = gTTS(text=text, lang='en', slow=(speed < 1.0))
+        
+        # Use a temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.mp3') as tmp_file:
+            tts.save(tmp_file.name)
+            return tmp_file.name, '<div class="status-success">✅ Audio generated successfully</div>'
+    
+    except Exception as e:
+        return None, f'<div class="status-error">❌ Error generating audio: {str(e)}</div>'

bun.lockb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a3c575fd4a99dc9d1d74a4a7a31b979d577c15f379bc5cb0dd7e823586e98c23
+size 198351

config.py

@@ -0,0 +1,11 @@
+
+"""Configuration constants and settings for ScriptVoice."""
+
+PROJECTS_FILE = "projects.json"
+
+# ScriptVoice color scheme
+SCRIPT_RED = "#E63946"
+SCRIPT_GOLD = "#FFD700"
+SCRIPT_BLACK = "#000000"
+SCRIPT_DARK_GRAY = "#1a1a1a"
+SCRIPT_BORDER = "rgba(230, 57, 70, 0.2)"

enhancement_services.py

@@ -0,0 +1,60 @@
+
+"""AI enhancement services for ScriptVoice with RAG integration."""
+
+from typing import Tuple
+from langchain_tools import context_enhancer
+from rag_services import rag_service
+
+
+def enhance_script_placeholder(text: str, enhancement_type: str) -> Tuple[str, str]:
+    """Enhanced script enhancement with context awareness."""
+    if not text.strip():
+        return text, '<div class="status-error">❌ Please provide text to enhance</div>'
+    
+    # Use context-aware enhancement
+    enhanced_text, status = context_enhancer.enhance_script_with_context(text, enhancement_type)
+    
+    return enhanced_text, status
+
+
+def enhance_script_with_context(text: str, enhancement_type: str) -> Tuple[str, str]:
+    """Context-aware script enhancement using RAG."""
+    return context_enhancer.enhance_script_with_context(text, enhancement_type)
+
+
+def analyze_character_consistency(text: str) -> Tuple[str, str]:
+    """Analyze character consistency in the provided text."""
+    if not text.strip():
+        return "", '<div class="status-error">❌ Please provide text to analyze</div>'
+    
+    analysis = context_enhancer.analyze_character_consistency(text)
+    
+    return analysis, '<div class="status-success">✅ Character consistency analysis complete</div>'
+
+
+def suggest_story_elements(text: str) -> Tuple[str, str]:
+    """Suggest relevant story elements for the text."""
+    if not text.strip():
+        return "", '<div class="status-error">❌ Please provide text for suggestions</div>'
+    
+    suggestions = context_enhancer.suggest_story_elements(text)
+    
+    return suggestions, '<div class="status-success">✅ Story element suggestions generated</div>'
+
+
+def update_knowledge_base(content_type: str, content_id: str, title: str, content: str) -> str:
+    """Update the knowledge base with new or modified content."""
+    try:
+        rag_service.add_content(content, content_type, content_id, title)
+        return '<div class="status-success">✅ Knowledge base updated</div>'
+    except Exception as e:
+        return f'<div class="status-error">❌ Error updating knowledge base: {str(e)}</div>'
+
+
+def remove_from_knowledge_base(content_id: str) -> str:
+    """Remove content from the knowledge base."""
+    try:
+        rag_service.remove_content(content_id)
+        return '<div class="status-success">✅ Content removed from knowledge base</div>'
+    except Exception as e:
+        return f'<div class="status-error">❌ Error removing from knowledge base: {str(e)}</div>'

export_services.py

@@ -0,0 +1,48 @@
+
+"""Export services for ScriptVoice."""
+
+import tempfile
+from gtts import gTTS
+from models import load_projects
+from typing import Tuple, Optional
+
+
+def export_project(project_id: str, export_type: str) -> Tuple[Optional[str], str]:
+    """Export project content."""
+    if not project_id:
+        return None, '<div class="status-error">❌ No project selected</div>'
+    
+    data = load_projects()
+    if project_id not in data["projects"]:
+        return None, '<div class="status-error">❌ Project not found</div>'
+    
+    project = data["projects"][project_id]
+    
+    if export_type == "text":
+        # Create text file
+        content = f"Project: {project['name']}\n"
+        content += f"Created: {project['created_at']}\n"
+        content += f"Word Count: {project['word_count']}\n\n"
+        content += "SCRIPT:\n" + "="*50 + "\n"
+        content += project['content'] + "\n\n"
+        content += "NOTES:\n" + "="*50 + "\n"
+        content += project['notes']
+        
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt', encoding='utf-8') as tmp_file:
+            tmp_file.write(content)
+            return tmp_file.name, '<div class="status-success">✅ Text file exported</div>'
+    
+    elif export_type == "audio":
+        # Generate TTS audio
+        if not project['content'].strip():
+            return None, '<div class="status-error">❌ No content to convert to audio</div>'
+        
+        try:
+            tts = gTTS(text=project['content'], lang='en')
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.mp3') as tmp_file:
+                tts.save(tmp_file.name)
+                return tmp_file.name, '<div class="status-success">✅ Audio file exported</div>'
+        except Exception as e:
+            return None, f'<div class="status-error">❌ Error generating audio: {str(e)}</div>'
+    
+    return None, '<div class="status-error">❌ Invalid export type</div>'

image_services.py

@@ -0,0 +1,23 @@
+
+"""Image processing and OCR services for ScriptVoice."""
+
+import pytesseract
+from PIL import Image
+from typing import Tuple
+
+
+def extract_text_from_image(image) -> Tuple[str, str]:
+    """Extract text from uploaded image using OCR."""
+    if image is None:
+        return "", '<div class="status-error">❌ Please upload an image</div>'
+    
+    try:
+        # Use pytesseract to extract text
+        text = pytesseract.image_to_string(Image.open(image))
+        if text.strip():
+            return text.strip(), '<div class="status-success">✅ Text extracted successfully</div>'
+        else:
+            return "", '<div class="status-error">❌ No text found in the image</div>'
+    
+    except Exception as e:
+        return "", f'<div class="status-error">❌ Error extracting text: {str(e)}</div>'

index.html

@@ -1,27 +1,26 @@
 
-<!DOCTYPE html>
+<!doctype html>
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.ico" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Script Voice - TTS Script Editor</title>
-    <meta name="description" content="Text-to-speech script editor for writers" />
-    <meta name="author" content="Lovable" />
-
-    <meta property="og:title" content="Script Voice - TTS Script Editor" />
-    <meta property="og:description" content="Text-to-speech script editor for writers" />
-    <meta property="og:type" content="website" />
-    <meta property="og:image" content="https://lovable.dev/opengraph-image-p98pqg.png" />
-
-    <meta name="twitter:card" content="summary_large_image" />
-    <meta name="twitter:site" content="@lovable_dev" />
-    <meta name="twitter:image" content="https://lovable.dev/opengraph-image-p98pqg.png" />
+    <title>ScriptVoice - Python Gradio App</title>
   </head>
-
   <body>
-    <div id="root"></div>
-    <!-- IMPORTANT: DO NOT REMOVE THIS SCRIPT TAG OR THIS VERY COMMENT! -->
-    <script src="https://cdn.gpteng.co/gptengineer.js" type="module"></script>
-    <script type="module" src="/src/main.tsx"></script>
+    <div id="root">
+      <div style="padding: 20px; font-family: Arial, sans-serif; text-align: center;">
+        <h1>ScriptVoice - AI-Powered Story Intelligence Platform</h1>
+        <p>This is a Python Gradio application. To run it:</p>
+        <ol style="text-align: left; max-width: 400px; margin: 0 auto;">
+          <li>Install dependencies: <code>pip install -r requirements.txt</code></li>
+          <li>Run the app: <code>python main.py</code></li>
+          <li>Access at: <a href="http://localhost:7860">http://localhost:7860</a></li>
+        </ol>
+        <p style="margin-top: 20px; color: #666;">
+          The actual application interface will be served by Gradio on port 7860.
+        </p>
+      </div>
+    </div>
   </body>
 </html>

knowledge_assistant.py

@@ -0,0 +1,194 @@
+
+"""Knowledge assistant for intelligent content queries."""
+
+from typing import List, Dict, Any, Tuple
+from rag_services import rag_service
+
+
+class KnowledgeAssistant:
+    """Provides intelligent assistance based on the knowledge base."""
+    
+    def __init__(self):
+        self.commands = {
+            "!search": self.search_knowledge,
+            "!characters": self.list_characters,
+            "!stories": self.list_stories,
+            "!world": self.list_world_elements,
+            "!analyze": self.analyze_content,
+            "!suggest": self.suggest_related,
+            "!consistency": self.check_consistency,
+            "!rebuild": self.rebuild_index
+        }
+    
+    def process_query(self, query: str) -> str:
+        """Process user queries and provide intelligent responses."""
+        query = query.strip()
+        
+        # Check for commands
+        if query.startswith("!"):
+            command_parts = query.split(" ", 1)
+            command = command_parts[0]
+            args = command_parts[1] if len(command_parts) > 1 else ""
+            
+            if command in self.commands:
+                return self.commands[command](args)
+            else:
+                return f"Unknown command: {command}\nAvailable commands: {', '.join(self.commands.keys())}"
+        
+        # Regular search query
+        return self.search_knowledge(query)
+    
+    def search_knowledge(self, query: str) -> str:
+        """Search across all knowledge base content."""
+        if not query.strip():
+            return "Please provide a search query."
+        
+        results = rag_service.search(query, k=5)
+        
+        if not results:
+            return f"No results found for: {query}"
+        
+        response = f"🔍 SEARCH RESULTS FOR: '{query}'\n\n"
+        
+        for i, result in enumerate(results, 1):
+            metadata = result['metadata']
+            content_type = metadata.get('content_type', 'content')
+            title = metadata.get('title', 'Unknown')
+            content = result['content'][:200] + "..." if len(result['content']) > 200 else result['content']
+            score = result['score']
+            
+            response += f"{i}. {content_type.title()}: {title} (Relevance: {score:.2f})\n"
+            response += f"   {content}\n\n"
+        
+        return response
+    
+    def list_characters(self, query: str = "") -> str:
+        """List characters in the knowledge base."""
+        results = rag_service.search(query if query else "character", k=10, content_type="character")
+        
+        if not results:
+            return "No characters found in knowledge base."
+        
+        response = "👥 CHARACTERS IN KNOWLEDGE BASE:\n\n"
+        for result in results:
+            title = result['metadata'].get('title', 'Unknown')
+            content = result['content'][:150] + "..." if len(result['content']) > 150 else result['content']
+            response += f"• {title}\n  {content}\n\n"
+        
+        return response
+    
+    def list_stories(self, query: str = "") -> str:
+        """List stories in the knowledge base."""
+        results = rag_service.search(query if query else "story", k=10, content_type="story")
+        
+        if not results:
+            return "No stories found in knowledge base."
+        
+        response = "📚 STORIES IN KNOWLEDGE BASE:\n\n"
+        for result in results:
+            title = result['metadata'].get('title', 'Unknown')
+            content = result['content'][:150] + "..." if len(result['content']) > 150 else result['content']
+            response += f"• {title}\n  {content}\n\n"
+        
+        return response
+    
+    def list_world_elements(self, query: str = "") -> str:
+        """List world elements in the knowledge base."""
+        results = rag_service.search(query if query else "world", k=10, content_type="world_element")
+        
+        if not results:
+            return "No world elements found in knowledge base."
+        
+        response = "🌍 WORLD ELEMENTS IN KNOWLEDGE BASE:\n\n"
+        for result in results:
+            title = result['metadata'].get('title', 'Unknown')
+            content = result['content'][:150] + "..." if len(result['content']) > 150 else result['content']
+            response += f"• {title}\n  {content}\n\n"
+        
+        return response
+    
+    def analyze_content(self, content: str) -> str:
+        """Analyze provided content against the knowledge base."""
+        if not content.strip():
+            return "Please provide content to analyze."
+        
+        # Find related content
+        results = rag_service.search(content, k=5)
+        
+        response = "📊 CONTENT ANALYSIS:\n\n"
+        
+        if results:
+            response += "Related content found:\n"
+            for result in results:
+                metadata = result['metadata']
+                content_type = metadata.get('content_type', 'content')
+                title = metadata.get('title', 'Unknown')
+                score = result['score']
+                response += f"• {content_type.title()}: {title} (Similarity: {score:.2f})\n"
+        else:
+            response += "No related content found in knowledge base."
+        
+        return response
+    
+    def suggest_related(self, content: str) -> str:
+        """Suggest related content based on input."""
+        if not content.strip():
+            return "Please provide content for suggestions."
+        
+        # Get diverse suggestions
+        char_results = rag_service.search(content, k=2, content_type="character")
+        story_results = rag_service.search(content, k=2, content_type="story")
+        world_results = rag_service.search(content, k=2, content_type="world_element")
+        
+        response = "💡 SUGGESTIONS BASED ON YOUR CONTENT:\n\n"
+        
+        if char_results:
+            response += "Relevant Characters:\n"
+            for result in char_results:
+                title = result['metadata'].get('title', 'Unknown')
+                response += f"• {title}\n"
+            response += "\n"
+        
+        if story_results:
+            response += "Related Stories:\n"
+            for result in story_results:
+                title = result['metadata'].get('title', 'Unknown')
+                response += f"• {title}\n"
+            response += "\n"
+        
+        if world_results:
+            response += "Relevant World Elements:\n"
+            for result in world_results:
+                title = result['metadata'].get('title', 'Unknown')
+                response += f"• {title}\n"
+            response += "\n"
+        
+        if not any([char_results, story_results, world_results]):
+            response += "No related content found in knowledge base."
+        
+        return response
+    
+    def check_consistency(self, content: str) -> str:
+        """Check content consistency against knowledge base."""
+        if not content.strip():
+            return "Please provide content to check for consistency."
+        
+        from langchain_tools import context_enhancer
+        analysis = context_enhancer.analyze_character_consistency(content)
+        
+        response = "✅ CONSISTENCY CHECK:\n\n"
+        response += analysis
+        
+        return response
+    
+    def rebuild_index(self, args: str = "") -> str:
+        """Rebuild the vector index from current data."""
+        try:
+            rag_service.rebuild_index_from_projects()
+            return "✅ Knowledge base index rebuilt successfully!"
+        except Exception as e:
+            return f"❌ Error rebuilding index: {str(e)}"
+
+
+# Global assistant instance
+knowledge_assistant = KnowledgeAssistant()

langchain_tools.py

@@ -0,0 +1,217 @@
+
+"""LangChain tools and chains for context-aware AI enhancement."""
+
+from typing import List, Dict, Any, Optional
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from langchain.schema import BaseOutputParser
+from rag_services import rag_service
+
+
+class ContextAwareEnhancer:
+    """Handles context-aware script enhancement using RAG."""
+    
+    def __init__(self):
+        self.enhancement_prompts = {
+            "dramatic": """
+You are enhancing a script with dramatic flair. Use the following context about characters and story elements to make the enhancement more consistent and engaging.
+
+CONTEXT:
+{context}
+
+ORIGINAL SCRIPT:
+{script}
+
+Please enhance this script with dramatic elements while maintaining consistency with the established characters and world. Focus on:
+- Heightened emotional stakes
+- Compelling character motivations
+- Dramatic tension and conflict
+- Rich, evocative language
+
+ENHANCED SCRIPT:
+""",
+            "romantic": """
+You are enhancing a script with romantic elements. Use the following context about characters and relationships to create authentic romantic moments.
+
+CONTEXT:
+{context}
+
+ORIGINAL SCRIPT:
+{script}
+
+Please enhance this script with romantic elements while staying true to the established characters and their relationships. Focus on:
+- Emotional intimacy and connection
+- Character chemistry and dynamics
+- Tender, heartfelt dialogue
+- Romantic atmosphere and mood
+
+ENHANCED SCRIPT:
+""",
+            "professional": """
+You are enhancing a script for professional presentation. Use the following context to ensure accuracy and consistency.
+
+CONTEXT:
+{context}
+
+ORIGINAL SCRIPT:
+{script}
+
+Please enhance this script for a professional context while maintaining consistency with established facts and characters. Focus on:
+- Clear, authoritative language
+- Proper structure and flow
+- Professional tone and delivery
+- Accurate information and details
+
+ENHANCED SCRIPT:
+""",
+            "casual": """
+You are making a script more casual and conversational. Use the following context about characters to match their established personalities.
+
+CONTEXT:
+{context}
+
+ORIGINAL SCRIPT:
+{script}
+
+Please enhance this script with a casual, conversational tone while keeping character voices consistent. Focus on:
+- Natural, everyday language
+- Relaxed, friendly tone
+- Character-appropriate dialogue
+- Conversational flow and rhythm
+
+ENHANCED SCRIPT:
+""",
+            "character_consistent": """
+You are enhancing a script to be more consistent with established characters. Use the character information below to guide your enhancement.
+
+CHARACTER CONTEXT:
+{context}
+
+ORIGINAL SCRIPT:
+{script}
+
+Please enhance this script to be more consistent with the established characters. Ensure:
+- Dialogue matches character personalities and speech patterns
+- Actions align with character motivations
+- Character relationships are honored
+- Character development feels authentic
+
+ENHANCED SCRIPT:
+""",
+            "plot_coherent": """
+You are enhancing a script to improve plot coherence. Use the story context below to ensure consistency.
+
+STORY CONTEXT:
+{context}
+
+ORIGINAL SCRIPT:
+{script}
+
+Please enhance this script to improve plot coherence and consistency. Focus on:
+- Logical story progression
+- Consistent world-building elements
+- Proper setup and payoff
+- Clear cause and effect relationships
+
+ENHANCED SCRIPT:
+"""
+        }
+    
+    def get_relevant_context(self, script: str, enhancement_type: str, max_context_length: int = 1000) -> str:
+        """Get relevant context for script enhancement."""
+        if not script.strip():
+            return "No relevant context found."
+        
+        # Search for relevant content
+        results = rag_service.search(script, k=5)
+        
+        if not results:
+            return "No relevant context found."
+        
+        # Build context string
+        context_parts = []
+        current_length = 0
+        
+        for result in results:
+            metadata = result['metadata']
+            content = result['content']
+            
+            # Create context entry
+            context_entry = f"\n--- {metadata.get('content_type', 'Content').title()}: {metadata.get('title', 'Unknown')} ---\n{content}\n"
+            
+            if current_length + len(context_entry) > max_context_length:
+                break
+            
+            context_parts.append(context_entry)
+            current_length += len(context_entry)
+        
+        return "\n".join(context_parts) if context_parts else "No relevant context found."
+    
+    def enhance_script_with_context(self, script: str, enhancement_type: str) -> tuple[str, str]:
+        """Enhance script using relevant context from the knowledge base."""
+        if enhancement_type not in self.enhancement_prompts:
+            return script, f'<div class="status-error">❌ Unknown enhancement type: {enhancement_type}</div>'
+        
+        # Get relevant context
+        context = self.get_relevant_context(script, enhancement_type)
+        
+        # For now, return a placeholder with context info
+        enhanced_script = f"""[CONTEXT-AWARE {enhancement_type.upper()} ENHANCEMENT]
+
+RELEVANT CONTEXT FOUND:
+{context[:300]}{'...' if len(context) > 300 else ''}
+
+ENHANCED SCRIPT:
+{script}
+
+(Note: Full LLM integration will be added when API keys are configured)
+"""
+        
+        status_message = f'<div class="status-success">✅ Enhanced with {enhancement_type} style using relevant context from knowledge base</div>'
+        return enhanced_script, status_message
+    
+    def analyze_character_consistency(self, script: str) -> str:
+        """Analyze script for character consistency."""
+        # Search for character-related content
+        results = rag_service.search(script, k=3, content_type="character")
+        
+        if not results:
+            return "No character information found in knowledge base."
+        
+        analysis = "CHARACTER CONSISTENCY ANALYSIS:\n\n"
+        for result in results:
+            char_name = result['metadata'].get('title', 'Unknown Character')
+            analysis += f"• {char_name}: Found in knowledge base\n"
+            analysis += f"  Context: {result['content'][:100]}...\n\n"
+        
+        return analysis
+    
+    def suggest_story_elements(self, script: str) -> str:
+        """Suggest relevant story elements for the script."""
+        # Search across all content types
+        story_results = rag_service.search(script, k=2, content_type="story")
+        world_results = rag_service.search(script, k=2, content_type="world_element")
+        
+        suggestions = "STORY ELEMENT SUGGESTIONS:\n\n"
+        
+        if story_results:
+            suggestions += "Related Stories:\n"
+            for result in story_results:
+                title = result['metadata'].get('title', 'Unknown')
+                suggestions += f"• {title}\n"
+        
+        if world_results:
+            suggestions += "\nRelevant World Elements:\n"
+            for result in world_results:
+                title = result['metadata'].get('title', 'Unknown')
+                elem_type = result['metadata'].get('content_type', 'element')
+                suggestions += f"• {title} ({elem_type})\n"
+        
+        if not story_results and not world_results:
+            suggestions += "No relevant story elements found."
+        
+        return suggestions
+
+
+# Global enhancer instance
+context_enhancer = ContextAwareEnhancer()

main.py

@@ -0,0 +1,594 @@
+
+"""Main application entry point for ScriptVoice - Pure Gradio Application."""
+
+import gradio as gr
+from models import (
+    load_projects, create_new_project, load_project, 
+    save_script_content, update_word_count,
+    create_story, create_character, create_world_element,
+    get_all_stories, get_all_characters, get_all_world_elements,
+    search_content
+)
+from ui_components import CUSTOM_CSS, get_header_html, get_section_header
+from audio_services import generate_tts
+from image_services import extract_text_from_image
+from enhancement_services import (
+    enhance_script_placeholder, enhance_script_with_context,
+    analyze_character_consistency, suggest_story_elements
+)
+from export_services import export_project
+from knowledge_assistant import knowledge_assistant
+
+
+# Global state for current project
+current_project_id = None
+
+
+def create_story_intelligence_interface():
+    """Create the story intelligence interface components."""
+    
+    with gr.Column():
+        # Knowledge Assistant
+        gr.HTML(get_section_header('🤖 Knowledge Assistant'))
+        with gr.Group():
+            assistant_query = gr.Textbox(
+                label="Ask your Knowledge Assistant", 
+                placeholder="Try: !search dragons, !characters, !stories, or ask any question about your stories...",
+                lines=2
+            )
+            assistant_btn = gr.Button("🔍 Query Assistant", elem_classes=["primary-button"])
+            assistant_response = gr.HTML(visible=False)
+        
+        # Enhanced AI Tools
+        gr.HTML(get_section_header('🎯 Context-Aware AI Tools'))
+        with gr.Group():
+            ai_analysis_text = gr.Textbox(
+                label="Text to Analyze", 
+                placeholder="Paste your script text here for context-aware analysis...",
+                lines=4
+            )
+            with gr.Row():
+                consistency_btn = gr.Button("✅ Check Character Consistency", elem_classes=["secondary-button"])
+                suggest_btn = gr.Button("💡 Suggest Story Elements", elem_classes=["secondary-button"])
+                context_enhance_btn = gr.Button("🎭 Context-Aware Enhancement", elem_classes=["primary-button"])
+            
+            context_enhancement_type = gr.Dropdown(
+                choices=["character_consistent", "plot_coherent", "dramatic", "romantic"],
+                label="Enhancement Type",
+                value="character_consistent"
+            )
+            ai_analysis_output = gr.HTML(visible=False)
+        
+        # Search functionality
+        gr.HTML(get_section_header('🔍 Search Knowledge Base'))
+        with gr.Row():
+            search_input = gr.Textbox(label="Search", placeholder="Search stories, characters, world...")
+            search_btn = gr.Button("🔍 Search", elem_classes=["primary-button"])
+        search_results = gr.HTML(visible=False)
+        
+        # Story Management
+        gr.HTML(get_section_header('📚 Stories'))
+        with gr.Group():
+            new_story_title = gr.Textbox(label="Story Title", placeholder="Enter story title...")
+            new_story_desc = gr.Textbox(label="Description", placeholder="Brief description...", lines=2)
+            create_story_btn = gr.Button("📖 Create Story", elem_classes=["primary-button"])
+            story_status = gr.HTML(visible=False)
+        
+        story_dropdown = gr.Dropdown(label="Select Story", choices=[])
+        stories_display = gr.HTML()
+        
+        # Character Management
+        gr.HTML(get_section_header('👥 Characters'))
+        with gr.Group():
+            new_char_name = gr.Textbox(label="Character Name", placeholder="Enter character name...")
+            new_char_desc = gr.Textbox(label="Description", placeholder="Character description...", lines=2)
+            create_char_btn = gr.Button("👤 Create Character", elem_classes=["primary-button"])
+            char_status = gr.HTML(visible=False)
+        
+        character_dropdown = gr.Dropdown(label="Select Character", choices=[])
+        characters_display = gr.HTML()
+        
+        # World Building
+        gr.HTML(get_section_header('🌍 World Elements'))
+        with gr.Group():
+            new_world_name = gr.Textbox(label="Element Name", placeholder="Enter element name...")
+            world_type = gr.Dropdown(
+                choices=["location", "organization", "concept", "item"],
+                label="Type",
+                value="location"
+            )
+            new_world_desc = gr.Textbox(label="Description", placeholder="Element description...", lines=2)
+            create_world_btn = gr.Button("🏛️ Create Element", elem_classes=["primary-button"])
+            world_status = gr.HTML(visible=False)
+        
+        world_dropdown = gr.Dropdown(label="Select World Element", choices=[])
+        world_display = gr.HTML()
+        
+        # Knowledge Base Management
+        gr.HTML(get_section_header('⚙️ Knowledge Base Management'))
+        with gr.Group():
+            rebuild_btn = gr.Button("🔄 Rebuild Knowledge Index", elem_classes=["secondary-button"])
+            rebuild_status = gr.HTML(visible=False)
+    
+    return {
+        'assistant_query': assistant_query,
+        'assistant_btn': assistant_btn,
+        'assistant_response': assistant_response,
+        'ai_analysis_text': ai_analysis_text,
+        'consistency_btn': consistency_btn,
+        'suggest_btn': suggest_btn,
+        'context_enhance_btn': context_enhance_btn,
+        'context_enhancement_type': context_enhancement_type,
+        'ai_analysis_output': ai_analysis_output,
+        'search_input': search_input,
+        'search_btn': search_btn,
+        'search_results': search_results,
+        'new_story_title': new_story_title,
+        'new_story_desc': new_story_desc,
+        'create_story_btn': create_story_btn,
+        'story_status': story_status,
+        'story_dropdown': story_dropdown,
+        'stories_display': stories_display,
+        'new_char_name': new_char_name,
+        'new_char_desc': new_char_desc,
+        'create_char_btn': create_char_btn,
+        'char_status': char_status,
+        'character_dropdown': character_dropdown,
+        'characters_display': characters_display,
+        'new_world_name': new_world_name,
+        'world_type': world_type,
+        'new_world_desc': new_world_desc,
+        'create_world_btn': create_world_btn,
+        'world_status': world_status,
+        'world_dropdown': world_dropdown,
+        'world_display': world_display,
+        'rebuild_btn': rebuild_btn,
+        'rebuild_status': rebuild_status
+    }
+
+
+def query_knowledge_assistant(query: str) -> tuple[str, any]:
+    """Process knowledge assistant queries."""
+    if not query.strip():
+        return "Please enter a query.", gr.update(visible=False)
+    
+    try:
+        response = knowledge_assistant.process_query(query)
+        formatted_response = f'<div class="search-results"><pre>{response}</pre></div>'
+        return formatted_response, gr.update(visible=True)
+    except Exception as e:
+        error_response = f'<div class="status-error">❌ Error processing query: {str(e)}</div>'
+        return error_response, gr.update(visible=True)
+
+
+def analyze_consistency(text: str) -> tuple[str, any]:
+    """Analyze character consistency."""
+    if not text.strip():
+        return "Please provide text to analyze.", gr.update(visible=False)
+    
+    analysis, status = analyze_character_consistency(text)
+    formatted_response = f'<div class="search-results"><h4>Character Consistency Analysis</h4><pre>{analysis}</pre></div>'
+    return formatted_response, gr.update(visible=True)
+
+
+def suggest_elements(text: str) -> tuple[str, any]:
+    """Suggest story elements."""
+    if not text.strip():
+        return "Please provide text for suggestions.", gr.update(visible=False)
+    
+    suggestions, status = suggest_story_elements(text)
+    formatted_response = f'<div class="search-results"><h4>Story Element Suggestions</h4><pre>{suggestions}</pre></div>'
+    return formatted_response, gr.update(visible=True)
+
+
+def enhance_with_context(text: str, enhancement_type: str) -> tuple[str, any]:
+    """Enhance text with context awareness."""
+    if not text.strip():
+        return "Please provide text to enhance.", gr.update(visible=False)
+    
+    enhanced, status = enhance_script_with_context(text, enhancement_type)
+    formatted_response = f'<div class="search-results"><h4>Context-Aware Enhancement ({enhancement_type})</h4><pre>{enhanced}</pre></div>'
+    return formatted_response, gr.update(visible=True)
+
+
+def rebuild_knowledge_index() -> tuple[str, any]:
+    """Rebuild the knowledge base index."""
+    try:
+        from rag_services import rag_service
+        rag_service.rebuild_index_from_projects()
+        response = '<div class="status-success">✅ Knowledge base index rebuilt successfully!</div>'
+        return response, gr.update(visible=True)
+    except Exception as e:
+        response = f'<div class="status-error">❌ Error rebuilding index: {str(e)}</div>'
+        return response, gr.update(visible=True)
+
+
+def display_stories():
+    """Display all stories in a formatted way."""
+    stories = get_all_stories()
+    if not stories:
+        return "<p>No stories created yet.</p>"
+    
+    html = "<div class='stories-grid'>"
+    for story in stories:
+        html += f"""
+        <div class='story-card'>
+            <h3>{story['title']}</h3>
+            <p>{story['description'][:100]}{'...' if len(story['description']) > 100 else ''}</p>
+            <small>Created: {story['created_at'][:10]}</small>
+        </div>
+        """
+    html += "</div>"
+    return html
+
+
+def display_characters():
+    """Display all characters in a formatted way."""
+    characters = get_all_characters()
+    if not characters:
+        return "<p>No characters created yet.</p>"
+    
+    html = "<div class='characters-grid'>"
+    for char in characters:
+        html += f"""
+        <div class='character-card'>
+            <h3>{char['name']}</h3>
+            <p>{char['description'][:100]}{'...' if len(char['description']) > 100 else ''}</p>
+            <small>Created: {char['created_at'][:10]}</small>
+        </div>
+        """
+    html += "</div>"
+    return html
+
+
+def display_world_elements():
+    """Display all world elements in a formatted way."""
+    elements = get_all_world_elements()
+    if not elements:
+        return "<p>No world elements created yet.</p>"
+    
+    html = "<div class='world-grid'>"
+    for elem in elements:
+        html += f"""
+        <div class='world-card'>
+            <h3>{elem['name']} <span class='type-badge'>{elem['type']}</span></h3>
+            <p>{elem['description'][:100]}{'...' if len(elem['description']) > 100 else ''}</p>
+            <small>Created: {elem['created_at'][:10]}</small>
+        </div>
+        """
+    html += "</div>"
+    return html
+
+
+def perform_search(query):
+    """Perform search across all content."""
+    if not query.strip():
+        return gr.update(visible=False)
+    
+    results = search_content(query)
+    
+    html = f"<h4>Search Results for: '{query}'</h4>"
+    
+    if results['stories']:
+        html += "<h5>Stories:</h5><ul>"
+        for story in results['stories']:
+            html += f"<li><strong>{story['title']}</strong> - {story['description'][:50]}...</li>"
+        html += "</ul>"
+    
+    if results['characters']:
+        html += "<h5>Characters:</h5><ul>"
+        for char in results['characters']:
+            html += f"<li><strong>{char['name']}</strong> - {char['description'][:50]}...</li>"
+        html += "</ul>"
+    
+    if results['world_elements']:
+        html += "<h5>World Elements:</h5><ul>"
+        for elem in results['world_elements']:
+            html += f"<li><strong>{elem['name']}</strong> ({elem['type']}) - {elem['description'][:50]}...</li>"
+        html += "</ul>"
+    
+    if not any(results.values()):
+        html += "<p>No results found.</p>"
+    
+    return gr.update(value=html, visible=True)
+
+
+def create_interface():
+    """Create the main Gradio interface."""
+    
+    # Load initial projects
+    data = load_projects()
+    project_choices = [(proj["name"], proj_id) for proj_id, proj in data["projects"].items()]
+    
+    with gr.Blocks(
+        title="ScriptVoice - AI-Powered Story Intelligence Platform", 
+        theme=gr.themes.Base(),
+        css=CUSTOM_CSS
+    ) as app:
+        
+        # Header with ScriptVoice branding
+        gr.HTML(get_header_html())
+        
+        # Main tabbed interface
+        with gr.Tabs():
+            # Scripts Tab (Original functionality)
+            with gr.TabItem("📝 Scripts"):
+                with gr.Row():
+                    # Left Sidebar
+                    with gr.Column(scale=1, min_width=300, elem_classes=["sidebar-column"]):
+                        gr.HTML(get_section_header('📁 Projects'))
+                        
+                        # New Project Section
+                        with gr.Group():
+                            new_project_name = gr.Textbox(label="New Project Name", placeholder="Enter project name...")
+                            create_btn = gr.Button("➕ Create Project", elem_classes=["primary-button"])
+                            create_status = gr.HTML(visible=False)
+                        
+                        # Project Selection
+                        project_dropdown = gr.Dropdown(
+                            choices=project_choices,
+                            label="Select Project",
+                            value=list(data["projects"].keys())[0] if data["projects"] else None
+                        )
+                        
+                        # Notes Section
+                        gr.HTML(get_section_header('📝 Notes'))
+                        notes_textbox = gr.Textbox(
+                            label="Project Notes",
+                            placeholder="Add your notes here...",
+                            lines=5,
+                            max_lines=10
+                        )
+                        
+                        # Settings Section
+                        gr.HTML(get_section_header('⚙️ Settings'))
+                        with gr.Group():
+                            dyslexic_mode = gr.Checkbox(label="Dyslexic-friendly font", value=False)
+                            voice_speed = gr.Slider(0.5, 2.0, value=1.0, step=0.1, label="Voice Speed")
+                            voice_volume = gr.Slider(0.1, 1.0, value=1.0, step=0.1, label="Voice Volume")
+                    
+                    # Main Editor Panel
+                    with gr.Column(scale=2):
+                        # Word Count Display
+                        word_count_display = gr.HTML('<div class="word-count-highlight">📊 Word Count: 0</div>')
+                        
+                        # Script Editor
+                        script_textbox = gr.Textbox(
+                            label="Script Editor",
+                            placeholder="Start writing your script here...",
+                            lines=15,
+                            max_lines=25
+                        )
+                        
+                        # Control Buttons Row
+                        with gr.Row():
+                            save_btn = gr.Button("💾 Save", elem_classes=["secondary-button"])
+                            tts_btn = gr.Button("🔊 Play TTS", elem_classes=["primary-button"])
+                            save_status = gr.HTML(visible=False)
+                        
+                        # TTS Audio Output
+                        audio_output = gr.Audio(label="Generated Audio")
+                        tts_status = gr.HTML(visible=False)
+                        
+                        # OCR Section
+                        with gr.Group():
+                            gr.HTML(get_section_header('📷 Extract Text from Image'))
+                            with gr.Row():
+                                image_input = gr.Image(type="filepath", label="Upload Image")
+                                ocr_btn = gr.Button("Extract Text", elem_classes=["secondary-button"])
+                            ocr_status = gr.HTML(visible=False)
+                        
+                        # AI Enhancement Section
+                        with gr.Group():
+                            gr.HTML(get_section_header('🤖 AI Script Enhancement'))
+                            with gr.Row():
+                                enhancement_type = gr.Dropdown(
+                                    choices=["dramatic", "romantic", "professional", "casual"],
+                                    label="Enhancement Style",
+                                    value="dramatic"
+                                )
+                                enhance_btn = gr.Button("✨ Enhance Script", elem_classes=["primary-button"])
+                            enhance_status = gr.HTML(visible=False)
+                        
+                        # Export Section
+                        with gr.Group():
+                            gr.HTML(get_section_header('📤 Export'))
+                            with gr.Row():
+                                export_type = gr.Dropdown(
+                                    choices=["text", "audio"],
+                                    label="Export Type",
+                                    value="text"
+                                )
+                                export_btn = gr.Button("📥 Export", elem_classes=["secondary-button"])
+                            export_file = gr.File(label="Download")
+                            export_status = gr.HTML(visible=False)
+            
+            # Story Intelligence Tab (Enhanced with RAG)
+            with gr.TabItem("📚 Story Intelligence"):
+                story_components = create_story_intelligence_interface()
+        
+        # Event Handlers for Scripts Tab
+        
+        # Create new project
+        create_btn.click(
+            fn=create_new_project,
+            inputs=[new_project_name],
+            outputs=[create_status, project_dropdown]
+        ).then(
+            lambda: ("", gr.update(visible=True)),
+            outputs=[new_project_name, create_status]
+        )
+        
+        # Load project when selected
+        project_dropdown.change(
+            fn=load_project,
+            inputs=[project_dropdown],
+            outputs=[script_textbox, notes_textbox, word_count_display]
+        )
+        
+        # Update word count as user types
+        script_textbox.change(
+            fn=update_word_count,
+            inputs=[script_textbox],
+            outputs=[word_count_display]
+        )
+        
+        # Save script content
+        save_btn.click(
+            fn=save_script_content,
+            inputs=[project_dropdown, script_textbox, notes_textbox],
+            outputs=[save_status]
+        ).then(
+            lambda: gr.update(visible=True),
+            outputs=[save_status]
+        )
+        
+        # Generate TTS
+        tts_btn.click(
+            fn=generate_tts,
+            inputs=[script_textbox, voice_speed],
+            outputs=[audio_output, tts_status]
+        ).then(
+            lambda: gr.update(visible=True),
+            outputs=[tts_status]
+        )
+        
+        # OCR text extraction
+        ocr_btn.click(
+            fn=extract_text_from_image,
+            inputs=[image_input],
+            outputs=[script_textbox, ocr_status]
+        ).then(
+            lambda: gr.update(visible=True),
+            outputs=[ocr_status]
+        )
+        
+        # AI Enhancement
+        enhance_btn.click(
+            fn=enhance_script_placeholder,
+            inputs=[script_textbox, enhancement_type],
+            outputs=[script_textbox, enhance_status]
+        ).then(
+            lambda: gr.update(visible=True),
+            outputs=[enhance_status]
+        )
+        
+        # Export functionality
+        export_btn.click(
+            fn=export_project,
+            inputs=[project_dropdown, export_type],
+            outputs=[export_file, export_status]
+        ).then(
+            lambda: gr.update(visible=True),
+            outputs=[export_status]
+        )
+        
+        # Event Handlers for Story Intelligence Tab
+        
+        # Knowledge Assistant
+        story_components['assistant_btn'].click(
+            fn=query_knowledge_assistant,
+            inputs=[story_components['assistant_query']],
+            outputs=[story_components['assistant_response'], story_components['assistant_response']]
+        )
+        
+        # AI Analysis Tools
+        story_components['consistency_btn'].click(
+            fn=analyze_consistency,
+            inputs=[story_components['ai_analysis_text']],
+            outputs=[story_components['ai_analysis_output'], story_components['ai_analysis_output']]
+        )
+        
+        story_components['suggest_btn'].click(
+            fn=suggest_elements,
+            inputs=[story_components['ai_analysis_text']],
+            outputs=[story_components['ai_analysis_output'], story_components['ai_analysis_output']]
+        )
+        
+        story_components['context_enhance_btn'].click(
+            fn=enhance_with_context,
+            inputs=[story_components['ai_analysis_text'], story_components['context_enhancement_type']],
+            outputs=[story_components['ai_analysis_output'], story_components['ai_analysis_output']]
+        )
+        
+        # Knowledge Base Management
+        story_components['rebuild_btn'].click(
+            fn=rebuild_knowledge_index,
+            outputs=[story_components['rebuild_status'], story_components['rebuild_status']]
+        )
+        
+        # Create story
+        story_components['create_story_btn'].click(
+            fn=create_story,
+            inputs=[story_components['new_story_title'], story_components['new_story_desc']],
+            outputs=[story_components['story_status'], story_components['story_dropdown']]
+        ).then(
+            lambda: ("", "", gr.update(visible=True)),
+            outputs=[story_components['new_story_title'], story_components['new_story_desc'], story_components['story_status']]
+        ).then(
+            fn=display_stories,
+            outputs=[story_components['stories_display']]
+        )
+        
+        # Create character
+        story_components['create_char_btn'].click(
+            fn=create_character,
+            inputs=[story_components['new_char_name'], story_components['new_char_desc']],
+            outputs=[story_components['char_status'], story_components['character_dropdown']]
+        ).then(
+            lambda: ("", "", gr.update(visible=True)),
+            outputs=[story_components['new_char_name'], story_components['new_char_desc'], story_components['char_status']]
+        ).then(
+            fn=display_characters,
+            outputs=[story_components['characters_display']]
+        )
+        
+        # Create world element
+        story_components['create_world_btn'].click(
+            fn=create_world_element,
+            inputs=[story_components['new_world_name'], story_components['world_type'], story_components['new_world_desc']],
+            outputs=[story_components['world_status'], story_components['world_dropdown']]
+        ).then(
+            lambda: ("", "", gr.update(visible=True)),
+            outputs=[story_components['new_world_name'], story_components['new_world_desc'], story_components['world_status']]
+        ).then(
+            fn=display_world_elements,
+            outputs=[story_components['world_display']]
+        )
+        
+        # Search functionality
+        story_components['search_btn'].click(
+            fn=perform_search,
+            inputs=[story_components['search_input']],
+            outputs=[story_components['search_results']]
+        )
+        
+        # Load initial story intelligence data
+        app.load(
+            fn=display_stories,
+            outputs=[story_components['stories_display']]
+        )
+        app.load(
+            fn=display_characters,
+            outputs=[story_components['characters_display']]
+        )
+        app.load(
+            fn=display_world_elements,
+            outputs=[story_components['world_display']]
+        )
+    
+    return app
+
+
+if __name__ == "__main__":
+    print("🚀 Starting ScriptVoice - AI-Powered Story Intelligence Platform")
+    print("🌐 The app will be available at: http://localhost:7860")
+    
+    # Create and launch the app
+    app = create_interface()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True
+    )

models.py

@@ -0,0 +1,282 @@
+
+"""Data models and project management for ScriptVoice."""
+
+import json
+import os
+from datetime import datetime
+from typing import Dict, Any, Tuple, Optional, List
+from config import PROJECTS_FILE
+
+# ... keep existing code (Story Intelligence Data Models: Character, WorldElement, Scene, Chapter, Story classes)
+
+def load_projects() -> Dict[str, Any]:
+    """Load projects from JSON file."""
+    if os.path.exists(PROJECTS_FILE):
+        with open(PROJECTS_FILE, 'r') as f:
+            data = json.load(f)
+            # Ensure new story intelligence fields exist
+            if "stories" not in data:
+                data["stories"] = {}
+            if "characters" not in data:
+                data["characters"] = {}
+            if "world_elements" not in data:
+                data["world_elements"] = {}
+            return data
+    return {
+        "projects": {
+            "1": {
+                "id": "1",
+                "name": "Sample Script",
+                "content": "Welcome to ScriptVoice! This is your first script. Start editing to create amazing voice content.",
+                "notes": "This is a sample note for your script.",
+                "created_at": datetime.now().isoformat(),
+                "word_count": 0
+            }
+        },
+        "stories": {},
+        "characters": {},
+        "world_elements": {},
+        "settings": {
+            "dyslexic_mode": False,
+            "voice_speed": 1.0,
+            "voice_volume": 1.0
+        }
+    }
+
+
+def save_projects(data: Dict[str, Any]) -> None:
+    """Save projects to JSON file."""
+    with open(PROJECTS_FILE, 'w') as f:
+        json.dump(data, f, indent=2)
+
+
+# ... keep existing code (get_word_count, update_word_count functions)
+
+def create_new_project(name: str) -> Tuple[str, Optional[Any]]:
+    """Create a new project."""
+    if not name.strip():
+        return '<div class="status-error">❌ Please enter a project name</div>', None
+    
+    data = load_projects()
+    new_id = str(len(data["projects"]) + 1)
+    
+    data["projects"][new_id] = {
+        "id": new_id,
+        "name": name.strip(),
+        "content": "",
+        "notes": "",
+        "created_at": datetime.now().isoformat(),
+        "word_count": 0
+    }
+    
+    save_projects(data)
+    
+    # Return updated project choices and select the new project
+    import gradio as gr
+    choices = [(proj["name"], proj_id) for proj_id, proj in data["projects"].items()]
+    return f'<div class="status-success">✅ Project "{name}" created successfully!</div>', gr.update(choices=choices, value=new_id)
+
+
+def load_project(project_id: str) -> Tuple[str, str, str]:
+    """Load a specific project."""
+    if not project_id:
+        return "", "", '<div class="word-count-highlight">📊 Word Count: 0</div>'
+    
+    data = load_projects()
+    if project_id in data["projects"]:
+        project = data["projects"][project_id]
+        word_count = get_word_count(project["content"])
+        return project["content"], project["notes"], f'<div class="word-count-highlight">📊 Word Count: {word_count}</div>'
+    
+    return "", "", '<div class="word-count-highlight">📊 Word Count: 0</div>'
+
+
+def save_script_content(project_id: str, content: str, notes: str) -> str:
+    """Save script content and notes."""
+    if not project_id:
+        return '<div class="status-error">❌ No project selected</div>'
+    
+    data = load_projects()
+    if project_id in data["projects"]:
+        data["projects"][project_id]["content"] = content
+        data["projects"][project_id]["notes"] = notes
+        data["projects"][project_id]["word_count"] = get_word_count(content)
+        save_projects(data)
+        
+        # Update knowledge base
+        try:
+            from enhancement_services import update_knowledge_base
+            project_name = data["projects"][project_id]["name"]
+            update_knowledge_base("script", project_id, project_name, content)
+        except ImportError:
+            pass  # RAG services not available yet
+        
+        return '<div class="status-success">✅ Saved successfully</div>'
+    
+    return '<div class="status-error">❌ Error saving</div>'
+
+
+# Story Management Functions with RAG Integration
+def create_story(title: str, description: str = "") -> Tuple[str, Any]:
+    """Create a new story."""
+    if not title.strip():
+        return '<div class="status-error">❌ Please enter a story title</div>', None
+    
+    data = load_projects()
+    new_id = str(len(data["stories"]) + 1)
+    
+    story_data = {
+        "id": new_id,
+        "title": title.strip(),
+        "description": description,
+        "content": "",
+        "tags": [],
+        "characters": [],
+        "world_elements": [],
+        "chapters": [],
+        "created_at": datetime.now().isoformat(),
+        "updated_at": datetime.now().isoformat()
+    }
+    
+    data["stories"][new_id] = story_data
+    save_projects(data)
+    
+    # Update knowledge base
+    try:
+        from enhancement_services import update_knowledge_base
+        content = f"{title}\n\n{description}"
+        update_knowledge_base("story", new_id, title, content)
+    except ImportError:
+        pass  # RAG services not available yet
+    
+    import gradio as gr
+    choices = [(story["title"], story_id) for story_id, story in data["stories"].items()]
+    return f'<div class="status-success">✅ Story "{title}" created successfully!</div>', gr.update(choices=choices, value=new_id)
+
+
+def create_character(name: str, description: str = "") -> Tuple[str, Any]:
+    """Create a new character."""
+    if not name.strip():
+        return '<div class="status-error">❌ Please enter a character name</div>', None
+    
+    data = load_projects()
+    new_id = str(len(data["characters"]) + 1)
+    
+    character_data = {
+        "id": new_id,
+        "name": name.strip(),
+        "description": description,
+        "traits": [],
+        "relationships": {},
+        "notes": "",
+        "created_at": datetime.now().isoformat(),
+        "updated_at": datetime.now().isoformat()
+    }
+    
+    data["characters"][new_id] = character_data
+    save_projects(data)
+    
+    # Update knowledge base
+    try:
+        from enhancement_services import update_knowledge_base
+        content = f"{name}\n\n{description}"
+        update_knowledge_base("character", new_id, name, content)
+    except ImportError:
+        pass  # RAG services not available yet
+    
+    import gradio as gr
+    choices = [(char["name"], char_id) for char_id, char in data["characters"].items()]
+    return f'<div class="status-success">✅ Character "{name}" created successfully!</div>', gr.update(choices=choices, value=new_id)
+
+
+def create_world_element(name: str, element_type: str, description: str = "") -> Tuple[str, Any]:
+    """Create a new world element."""
+    if not name.strip():
+        return '<div class="status-error">❌ Please enter an element name</div>', None
+    
+    data = load_projects()
+    new_id = str(len(data["world_elements"]) + 1)
+    
+    element_data = {
+        "id": new_id,
+        "name": name.strip(),
+        "type": element_type,
+        "description": description,
+        "tags": [],
+        "notes": "",
+        "created_at": datetime.now().isoformat(),
+        "updated_at": datetime.now().isoformat()
+    }
+    
+    data["world_elements"][new_id] = element_data
+    save_projects(data)
+    
+    # Update knowledge base
+    try:
+        from enhancement_services import update_knowledge_base
+        content = f"{name} ({element_type})\n\n{description}"
+        update_knowledge_base("world_element", new_id, name, content)
+    except ImportError:
+        pass  # RAG services not available yet
+    
+    import gradio as gr
+    choices = [(elem["name"], elem_id) for elem_id, elem in data["world_elements"].items()]
+    return f'<div class="status-success">✅ World element "{name}" created successfully!</div>', gr.update(choices=choices, value=new_id)
+
+
+# ... keep existing code (get_all_stories, get_all_characters, get_all_world_elements, search_content functions)
+
+def get_word_count(text: str) -> int:
+    """Count words in text."""
+    if not text:
+        return 0
+    return len(text.split())
+
+
+def update_word_count(text: str) -> str:
+    """Update word count display with gold highlighting."""
+    count = get_word_count(text)
+    return f'<div class="word-count-highlight">📊 Word Count: {count}</div>'
+
+
+def get_all_stories() -> List[Dict]:
+    """Get all stories."""
+    data = load_projects()
+    return list(data["stories"].values())
+
+
+def get_all_characters() -> List[Dict]:
+    """Get all characters."""
+    data = load_projects()
+    return list(data["characters"].values())
+
+
+def get_all_world_elements() -> List[Dict]:
+    """Get all world elements."""
+    data = load_projects()
+    return list(data["world_elements"].values())
+
+
+def search_content(query: str) -> Dict[str, List[Dict]]:
+    """Search across stories, characters, and world elements."""
+    data = load_projects()
+    query_lower = query.lower()
+    
+    stories = [story for story in data["stories"].values() 
+               if query_lower in story["title"].lower() or 
+                  query_lower in story["description"].lower() or
+                  query_lower in story["content"].lower()]
+    
+    characters = [char for char in data["characters"].values()
+                  if query_lower in char["name"].lower() or
+                     query_lower in char["description"].lower()]
+    
+    world_elements = [elem for elem in data["world_elements"].values()
+                      if query_lower in elem["name"].lower() or
+                         query_lower in elem["description"].lower()]
+    
+    return {
+        "stories": stories,
+        "characters": characters,
+        "world_elements": world_elements
+    }

rag_services.py

@@ -0,0 +1,224 @@
+
+"""RAG (Retrieval Augmented Generation) services for ScriptVoice."""
+
+import os
+import json
+import pickle
+from typing import List, Dict, Any, Tuple, Optional
+from sentence_transformers import SentenceTransformer
+import faiss
+import numpy as np
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.docstore.document import Document
+from config import PROJECTS_FILE
+
+
+class RAGService:
+    """Handles vector database operations and content retrieval."""
+    
+    def __init__(self):
+        self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=500,
+            chunk_overlap=50,
+            separators=["\n\n", "\n", ". ", "! ", "? ", " "]
+        )
+        self.index = None
+        self.documents = []
+        self.metadata = []
+        self.index_file = "vector_index.faiss"
+        self.metadata_file = "vector_metadata.pkl"
+        self._load_or_create_index()
+    
+    def _load_or_create_index(self):
+        """Load existing index or create new one."""
+        if os.path.exists(self.index_file) and os.path.exists(self.metadata_file):
+            try:
+                self.index = faiss.read_index(self.index_file)
+                with open(self.metadata_file, 'rb') as f:
+                    data = pickle.load(f)
+                    self.documents = data['documents']
+                    self.metadata = data['metadata']
+                print(f"Loaded vector index with {len(self.documents)} documents")
+            except Exception as e:
+                print(f"Error loading index: {e}")
+                self._create_empty_index()
+        else:
+            self._create_empty_index()
+    
+    def _create_empty_index(self):
+        """Create empty FAISS index."""
+        dimension = 384  # all-MiniLM-L6-v2 dimension
+        self.index = faiss.IndexFlatIP(dimension)
+        self.documents = []
+        self.metadata = []
+    
+    def chunk_content(self, content: str, content_type: str, content_id: str, title: str) -> List[Document]:
+        """Split content into chunks for embedding."""
+        chunks = self.text_splitter.split_text(content)
+        documents = []
+        
+        for i, chunk in enumerate(chunks):
+            doc = Document(
+                page_content=chunk,
+                metadata={
+                    'content_type': content_type,
+                    'content_id': content_id,
+                    'title': title,
+                    'chunk_id': i,
+                    'chunk_count': len(chunks)
+                }
+            )
+            documents.append(doc)
+        
+        return documents
+    
+    def add_content(self, content: str, content_type: str, content_id: str, title: str):
+        """Add content to the vector database."""
+        if not content.strip():
+            return
+        
+        # Remove existing content for this ID
+        self.remove_content(content_id)
+        
+        # Chunk the content
+        documents = self.chunk_content(content, content_type, content_id, title)
+        
+        if not documents:
+            return
+        
+        # Generate embeddings
+        texts = [doc.page_content for doc in documents]
+        embeddings = self.model.encode(texts)
+        
+        # Normalize embeddings for cosine similarity
+        embeddings = embeddings / np.linalg.norm(embeddings, axis=1, keepdims=True)
+        
+        # Add to FAISS index
+        self.index.add(embeddings.astype('float32'))
+        
+        # Store documents and metadata
+        self.documents.extend(documents)
+        for doc in documents:
+            self.metadata.append(doc.metadata)
+        
+        # Save index
+        self._save_index()
+    
+    def remove_content(self, content_id: str):
+        """Remove content from vector database."""
+        indices_to_remove = []
+        for i, metadata in enumerate(self.metadata):
+            if metadata.get('content_id') == content_id:
+                indices_to_remove.append(i)
+        
+        if indices_to_remove:
+            # Rebuild index without removed items
+            new_documents = []
+            new_metadata = []
+            new_embeddings = []
+            
+            for i, (doc, meta) in enumerate(zip(self.documents, self.metadata)):
+                if i not in indices_to_remove:
+                    new_documents.append(doc)
+                    new_metadata.append(meta)
+                    embedding = self.model.encode([doc.page_content])
+                    embedding = embedding / np.linalg.norm(embedding, axis=1, keepdims=True)
+                    new_embeddings.append(embedding[0])
+            
+            # Recreate index
+            self._create_empty_index()
+            if new_embeddings:
+                embeddings_array = np.array(new_embeddings).astype('float32')
+                self.index.add(embeddings_array)
+                self.documents = new_documents
+                self.metadata = new_metadata
+            
+            self._save_index()
+    
+    def search(self, query: str, k: int = 5, content_type: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Search for similar content."""
+        if self.index.ntotal == 0:
+            return []
+        
+        # Generate query embedding
+        query_embedding = self.model.encode([query])
+        query_embedding = query_embedding / np.linalg.norm(query_embedding, axis=1, keepdims=True)
+        
+        # Search
+        scores, indices = self.index.search(query_embedding.astype('float32'), min(k * 2, self.index.ntotal))
+        
+        results = []
+        for score, idx in zip(scores[0], indices[0]):
+            if idx >= 0 and idx < len(self.documents):
+                metadata = self.metadata[idx]
+                
+                # Filter by content type if specified
+                if content_type and metadata.get('content_type') != content_type:
+                    continue
+                
+                result = {
+                    'content': self.documents[idx].page_content,
+                    'metadata': metadata,
+                    'score': float(score)
+                }
+                results.append(result)
+                
+                if len(results) >= k:
+                    break
+        
+        return results
+    
+    def get_context_for_content(self, content_id: str, query: str, k: int = 3) -> List[Dict[str, Any]]:
+        """Get relevant context from other content for a specific item."""
+        results = self.search(query, k=k)
+        # Filter out results from the same content
+        filtered_results = [r for r in results if r['metadata'].get('content_id') != content_id]
+        return filtered_results[:k]
+    
+    def _save_index(self):
+        """Save FAISS index and metadata to disk."""
+        try:
+            faiss.write_index(self.index, self.index_file)
+            with open(self.metadata_file, 'wb') as f:
+                pickle.dump({
+                    'documents': self.documents,
+                    'metadata': self.metadata
+                }, f)
+        except Exception as e:
+            print(f"Error saving index: {e}")
+    
+    def rebuild_index_from_projects(self):
+        """Rebuild the entire vector index from current projects data."""
+        from models import load_projects
+        
+        # Clear existing index
+        self._create_empty_index()
+        
+        # Load all projects data
+        data = load_projects()
+        
+        # Add stories
+        for story_id, story in data.get("stories", {}).items():
+            content = f"{story['title']}\n\n{story['description']}\n\n{story['content']}"
+            self.add_content(content, "story", story_id, story['title'])
+        
+        # Add characters
+        for char_id, char in data.get("characters", {}).items():
+            content = f"{char['name']}\n\n{char['description']}\n\nTraits: {', '.join(char.get('traits', []))}\n\n{char.get('notes', '')}"
+            self.add_content(content, "character", char_id, char['name'])
+        
+        # Add world elements
+        for elem_id, elem in data.get("world_elements", {}).items():
+            content = f"{elem['name']} ({elem['type']})\n\n{elem['description']}\n\nTags: {', '.join(elem.get('tags', []))}\n\n{elem.get('notes', '')}"
+            self.add_content(content, "world_element", elem_id, elem['name'])
+        
+        # Add scripts
+        for proj_id, proj in data.get("projects", {}).items():
+            if proj.get('content'):
+                content = f"{proj['name']}\n\n{proj['content']}\n\nNotes: {proj.get('notes', '')}"
+                self.add_content(content, "script", proj_id, proj['name'])
+
+
+# Global RAG service instance
+rag_service = RAGService()

requirements.txt

@@ -4,3 +4,8 @@ gtts>=2.3.0
 pytesseract>=0.3.10
 Pillow>=10.0.0
 setuptools>=65.0.0
+langchain>=0.1.0
+sentence-transformers>=2.2.0
+faiss-cpu>=1.7.0
+langchain-openai>=0.1.0
+tiktoken>=0.5.0

run.py

@@ -0,0 +1,27 @@
+
+#!/usr/bin/env python3
+"""
+Simple launcher for ScriptVoice Gradio Application
+
+Install dependencies with:
+    pip install -r requirements.txt
+
+Then run:
+    python run.py
+"""
+
+if __name__ == "__main__":
+    from main import create_interface
+    
+    print("🚀 Starting ScriptVoice - AI-Powered Story Intelligence Platform")
+    print("📦 Make sure you have installed dependencies: pip install -r requirements.txt")
+    print("🌐 The app will be available at: http://localhost:7860")
+    
+    # Create and launch the app
+    app = create_interface()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True
+    )

ui_components.py

@@ -0,0 +1,396 @@
+
+"""UI components and styling for ScriptVoice application."""
+
+CUSTOM_CSS = """
+/* ScriptVoice Custom CSS - Black/White/Red/Gold Theme */
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+
+.gradio-container {
+    background: #000000 !important;
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif !important;
+    color: #FFFFFF !important;
+}
+
+.word-count-highlight {
+    background: #E63946 !important;
+    color: #FFFFFF !important;
+    font-weight: 600;
+    font-size: 1.1em;
+    padding: 12px 16px;
+    border-radius: 8px;
+    border: 2px solid #E63946;
+    box-shadow: 0 2px 8px rgba(230, 57, 70, 0.3);
+}
+
+.primary-button {
+    background: #E63946 !important;
+    border: none !important;
+    color: #FFFFFF !important;
+    font-weight: 600 !important;
+    font-family: 'Inter', sans-serif !important;
+    transition: all 0.3s ease !important;
+    border-radius: 6px !important;
+    padding: 12px 20px !important;
+}
+
+.primary-button:hover {
+    background: #d12a36 !important;
+    transform: translateY(-1px) !important;
+    box-shadow: 0 4px 12px rgba(230, 57, 70, 0.4) !important;
+}
+
+.secondary-button {
+    background: #1a1a1a !important;
+    border: 2px solid #FFD700 !important;
+    color: #FFD700 !important;
+    font-weight: 600 !important;
+    font-family: 'Inter', sans-serif !important;
+    transition: all 0.3s ease !important;
+    border-radius: 6px !important;
+    padding: 12px 20px !important;
+}
+
+.secondary-button:hover {
+    background: #FFD700 !important;
+    color: #000000 !important;
+    transform: translateY(-1px) !important;
+    box-shadow: 0 4px 12px rgba(255, 215, 0, 0.4) !important;
+}
+
+.sidebar-column {
+    background: #1a1a1a !important;
+    border-radius: 12px !important;
+    padding: 24px !important;
+    margin-right: 20px !important;
+    border: 1px solid #333333 !important;
+    box-shadow: 0 4px 16px rgba(0, 0, 0, 0.5) !important;
+}
+
+.status-success {
+    color: #FFD700 !important;
+    background-color: rgba(255, 215, 0, 0.1) !important;
+    border: 1px solid rgba(255, 215, 0, 0.3) !important;
+    padding: 12px 16px;
+    border-radius: 8px;
+    margin: 10px 0;
+    font-weight: 500;
+}
+
+.status-error {
+    color: #E63946 !important;
+    background-color: rgba(230, 57, 70, 0.1) !important;
+    border: 1px solid rgba(230, 57, 70, 0.3) !important;
+    padding: 12px 16px;
+    border-radius: 8px;
+    margin: 10px 0;
+    font-weight: 500;
+}
+
+/* Story Intelligence Styling */
+.stories-grid, .characters-grid, .world-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(320px, 1fr));
+    gap: 20px;
+    margin: 20px 0;
+}
+
+.story-card, .character-card, .world-card {
+    background: #1a1a1a !important;
+    border: 1px solid #333333 !important;
+    border-radius: 12px;
+    padding: 20px;
+    transition: all 0.3s ease;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.3);
+}
+
+.story-card:hover, .character-card:hover, .world-card:hover {
+    transform: translateY(-3px);
+    box-shadow: 0 8px 24px rgba(230, 57, 70, 0.2);
+    border-color: #E63946;
+}
+
+.story-card h3, .character-card h3, .world-card h3 {
+    color: #E63946 !important;
+    margin: 0 0 12px 0;
+    font-size: 1.2em;
+    font-weight: 600;
+    font-family: 'Inter', sans-serif;
+}
+
+.story-card p, .character-card p, .world-card p {
+    color: #CCCCCC !important;
+    margin: 10px 0;
+    line-height: 1.5;
+    font-weight: 400;
+}
+
+.story-card small, .character-card small, .world-card small {
+    color: #888888 !important;
+    font-size: 0.85em;
+    font-weight: 300;
+}
+
+.type-badge {
+    background: #FFD700 !important;
+    color: #000000 !important;
+    padding: 4px 12px;
+    border-radius: 12px;
+    font-size: 0.8em;
+    font-weight: 600;
+    margin-left: 10px;
+}
+
+/* Tab styling */
+.gradio-tabs .tab-nav {
+    background: #1a1a1a !important;
+    border-radius: 12px !important;
+    margin-bottom: 24px !important;
+    border: 1px solid #333333 !important;
+}
+
+.gradio-tabs .tab-nav button {
+    background: transparent !important;
+    color: #CCCCCC !important;
+    border: none !important;
+    padding: 14px 24px !important;
+    border-radius: 8px !important;
+    font-weight: 500 !important;
+    font-family: 'Inter', sans-serif !important;
+    transition: all 0.3s ease !important;
+}
+
+.gradio-tabs .tab-nav button.selected {
+    background: #E63946 !important;
+    color: #FFFFFF !important;
+    transform: translateY(-1px) !important;
+    box-shadow: 0 4px 12px rgba(230, 57, 70, 0.3) !important;
+}
+
+.gradio-tabs .tab-nav button:hover:not(.selected) {
+    background: rgba(255, 215, 0, 0.1) !important;
+    color: #FFD700 !important;
+}
+
+/* Search results styling */
+.search-results {
+    background: #1a1a1a !important;
+    border: 1px solid #333333 !important;
+    border-radius: 12px;
+    padding: 20px;
+    margin: 20px 0;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.3);
+}
+
+.search-results h4 {
+    color: #E63946 !important;
+    margin: 0 0 16px 0;
+    font-weight: 600;
+    font-family: 'Inter', sans-serif;
+}
+
+.search-results h5 {
+    color: #FFD700 !important;
+    margin: 16px 0 12px 0;
+    font-weight: 500;
+    font-family: 'Inter', sans-serif;
+}
+
+.search-results ul {
+    margin: 0 0 16px 20px;
+}
+
+.search-results li {
+    color: #CCCCCC !important;
+    margin: 8px 0;
+    line-height: 1.5;
+}
+
+.search-results pre {
+    background: #0a0a0a !important;
+    border: 1px solid #333333 !important;
+    border-radius: 6px;
+    padding: 16px;
+    color: #FFFFFF !important;
+    font-family: 'Inter', monospace;
+    overflow-x: auto;
+}
+
+/* Section headers */
+.section-header {
+    background: linear-gradient(45deg, #E63946, #FFD700) !important;
+    -webkit-background-clip: text !important;
+    -webkit-text-fill-color: transparent !important;
+    background-clip: text !important;
+    font-weight: 700;
+    font-size: 1.3em;
+    margin: 24px 0 16px 0;
+    padding: 12px 0;
+    border-bottom: 2px solid #E63946;
+    font-family: 'Inter', sans-serif;
+}
+
+/* Form groups */
+.gradio-group {
+    background: #1a1a1a !important;
+    border: 1px solid #333333 !important;
+    border-radius: 12px !important;
+    padding: 20px !important;
+    margin: 16px 0 !important;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.2) !important;
+}
+
+/* Input styling */
+.gradio-textbox input, .gradio-textbox textarea {
+    background: #0a0a0a !important;
+    border: 2px solid #333333 !important;
+    border-radius: 8px !important;
+    color: #FFFFFF !important;
+    padding: 12px 16px !important;
+    font-family: 'Inter', sans-serif !important;
+    font-weight: 400 !important;
+    transition: all 0.3s ease !important;
+}
+
+.gradio-textbox input:focus, .gradio-textbox textarea:focus {
+    border-color: #E63946 !important;
+    box-shadow: 0 0 0 3px rgba(230, 57, 70, 0.2) !important;
+    outline: none !important;
+}
+
+.gradio-textbox input::placeholder, .gradio-textbox textarea::placeholder {
+    color: #666666 !important;
+}
+
+.gradio-dropdown .wrap {
+    background: #0a0a0a !important;
+    border: 2px solid #333333 !important;
+    border-radius: 8px !important;
+    color: #FFFFFF !important;
+}
+
+.gradio-dropdown .wrap:focus-within {
+    border-color: #E63946 !important;
+    box-shadow: 0 0 0 3px rgba(230, 57, 70, 0.2) !important;
+}
+
+.gradio-dropdown .wrap .wrap-inner {
+    background: #0a0a0a !important;
+    color: #FFFFFF !important;
+}
+
+.gradio-dropdown .wrap .wrap-inner .token {
+    background: #E63946 !important;
+    color: #FFFFFF !important;
+}
+
+/* Label styling */
+.gradio-group label, .gradio-textbox label, .gradio-dropdown label {
+    color: #FFFFFF !important;
+    font-weight: 500 !important;
+    font-family: 'Inter', sans-serif !important;
+    margin-bottom: 8px !important;
+}
+
+/* Audio player styling */
+.gradio-audio {
+    background: #1a1a1a !important;
+    border: 1px solid #333333 !important;
+    border-radius: 8px !important;
+}
+
+/* File upload styling */
+.gradio-file {
+    background: #1a1a1a !important;
+    border: 2px dashed #333333 !important;
+    border-radius: 8px !important;
+    color: #FFFFFF !important;
+}
+
+.gradio-file:hover {
+    border-color: #E63946 !important;
+    background: rgba(230, 57, 70, 0.05) !important;
+}
+
+/* Progress bars */
+.gradio-progress {
+    background: #333333 !important;
+    border-radius: 4px !important;
+}
+
+.gradio-progress .progress-bar {
+    background: linear-gradient(45deg, #E63946, #FFD700) !important;
+    border-radius: 4px !important;
+}
+
+/* Slider styling */
+.gradio-slider input[type="range"] {
+    background: #333333 !important;
+}
+
+.gradio-slider input[type="range"]::-webkit-slider-thumb {
+    background: #E63946 !important;
+    border: 2px solid #FFFFFF !important;
+}
+
+.gradio-slider input[type="range"]::-moz-range-thumb {
+    background: #E63946 !important;
+    border: 2px solid #FFFFFF !important;
+}
+
+/* Checkbox styling */
+.gradio-checkbox input[type="checkbox"]:checked {
+    background: #E63946 !important;
+    border-color: #E63946 !important;
+}
+
+/* Scrollbar styling */
+::-webkit-scrollbar {
+    width: 8px;
+    height: 8px;
+}
+
+::-webkit-scrollbar-track {
+    background: #1a1a1a;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb {
+    background: #E63946;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: #d12a36;
+}
+
+/* Overall container styling */
+body, .gradio-container, .gradio-container > div {
+    background: #000000 !important;
+    color: #FFFFFF !important;
+}
+
+/* Ensure proper contrast for all text elements */
+h1, h2, h3, h4, h5, h6, p, span, div {
+    color: inherit !important;
+}
+"""
+
+def get_header_html():
+    """Generate the application header HTML."""
+    return """
+    <div style="text-align: center; padding: 40px 0; background: #000000; border-radius: 15px; margin-bottom: 30px; border: 2px solid #E63946; box-shadow: 0 4px 16px rgba(230, 57, 70, 0.3);">
+        <h1 style="margin: 0; font-size: 3.2em; background: linear-gradient(45deg, #E63946, #FFD700); -webkit-background-clip: text; -webkit-text-fill-color: transparent; font-weight: 700; font-family: 'Inter', sans-serif;">
+            🎬 ScriptVoice
+        </h1>
+        <p style="margin: 15px 0 0 0; color: #FFFFFF; font-size: 1.3em; font-weight: 400; font-family: 'Inter', sans-serif;">
+            AI-Powered Story Intelligence Platform
+        </p>
+        <p style="margin: 8px 0 0 0; color: #CCCCCC; font-size: 1em; font-weight: 300; font-family: 'Inter', sans-serif;">
+            Transform your stories with intelligent script writing, voice synthesis, and creative knowledge management
+        </p>
+    </div>
+    """
+
+def get_section_header(title):
+    """Generate a section header with consistent styling."""
+    return f'<div class="section-header">{title}</div>'

vite.config.js

@@ -0,0 +1,13 @@
+
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  // Minimal Vite config for compatibility
+  // The actual app runs on Python Gradio
+  build: {
+    outDir: 'dist',
+  },
+  server: {
+    port: 3000,
+  },
+})