Local changes before HF merge

.gitignore

@@ -1,5 +1,60 @@
+# Python
 __pycache__/
-*.pyc
-.env
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Database files (keep in git for deployment, but backup locally)
+# Uncomment next line if you don't want to track database in git
+# *.db
+
+# Backup files
+*.backup
+*.bak
+*.db.backup
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
 .DS_Store
-node_modules/
+Thumbs.db
+desktop.ini
+
+# Environment variables
+.env
+.env.local
+
+# Gradio
+flagged/
+gradio_cached_examples/
+
+# Logs
+*.log
+
+# Temporary files
+tmp/
+temp/

Dockerfile

@@ -1,10 +0,0 @@
-FROM python:3.9
-
-WORKDIR /app
-
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY . .
-
-CMD ["python", "app.py"]

MIGRATION_GUIDE.md

@@ -0,0 +1,332 @@
+# TextArchive - Migration Guide & New Features
+
+## 🎉 What Changed from "Prompt Manager" to "TextArchive"
+
+### Name Change
+- **Old**: Prompt Manager
+- **New**: TextArchive
+- **Why**: More universal - supports all text types, not just prompts
+
+### Database Changes
+- **Old**: `prompts.db` with table `prompts`
+- **New**: `textarchive.db` with table `text_items`
+- **Migration**: Automatic! Your old data is preserved and migrated
+
+---
+
+## ✨ NEW FEATURES IMPLEMENTED
+
+### 1. ✅ Easy Content Copying
+**The Problem You Had:**
+- Hard to copy just the text content
+- Would copy entire row with ID, category, section
+
+**The Solution:**
+- Click any row in the table
+- Content appears in "Content Preview" box below table
+- Click the copy button (📋) OR select text and Ctrl+C
+- Only the text content is copied - no metadata!
+
+**How to Use:**
+1. Go to "View & Manage Items" tab
+2. Click on any row
+3. Look at "Content Preview" section below
+4. Click copy button or manually select and copy
+
+---
+
+### 2. ✅ Auto-Filtering (AJAX-Style)
+**The Problem You Had:**
+- Had to click "Search" button every time
+- Not responsive
+
+**The Solution:**
+- Filters update automatically when you change them
+- No search button needed!
+- Instant feedback
+
+**How to Use:**
+1. Just select a category → table updates immediately
+2. Select a section → table updates immediately
+3. Select a content type → table updates immediately
+4. Click "Clear Filters" to reset
+
+---
+
+### 3. ✅ Fixed Height Table with Scrolling
+**The Problem You Had:**
+- Table grew huge with many items
+- Hard to navigate
+
+**The Solution:**
+- Table has fixed height (400px)
+- Scrolls internally when content exceeds height
+- Maintains clean, consistent interface
+
+**Result:**
+- Interface stays organized
+- Easy to browse large collections
+- Better user experience
+
+---
+
+### 4. ✅ Section Dropdown Filtering
+**The Problem You Had:**
+- Section dropdown showed ALL sections
+- Confusing when you had many categories
+
+**The Solution:**
+- Section dropdown automatically filters by selected category
+- Only shows sections that exist in that category
+- Much cleaner and more intuitive
+
+**How It Works:**
+1. Select a category
+2. Section dropdown automatically updates to show only relevant sections
+3. Works in both "Add" and "Edit" modes
+
+---
+
+### 5. ✅ Category & Section Renaming
+**Critical Feature You Were Missing:**
+- Could NOT rename categories/sections
+- Changing name created a new one, leaving old data orphaned
+
+**The Solution:**
+- New "Manage Categories & Sections" tab
+- Rename category → updates ALL items with that category
+- Rename section → updates ALL items with that section
+- Can rename section globally or within a specific category
+
+**How to Use:**
+1. Go to "⚙️ Manage Categories & Sections" tab
+2. Select category or section to rename
+3. Enter new name
+4. Click rename button
+5. All items are updated automatically!
+
+---
+
+### 6. ✅ Bulk Deletion
+**Critical Feature You Were Missing:**
+- Could only delete one item at a time
+- No way to clean up entire categories/sections
+
+**The Solution:**
+- Delete entire category (all items in it)
+- Delete entire section (all items in it, optionally within a category)
+- Confirmation required to prevent accidents
+- Shows count of items that will be deleted
+
+**How to Use:**
+1. Go to "⚙️ Manage Categories & Sections" tab
+2. Select category or section to delete
+3. Check the confirmation box
+4. Click delete button
+5. Status shows how many items were deleted
+
+---
+
+### 7. ✅ Content Type System
+**New Capability:**
+- Support for 11 different content types
+- Each type has icon and file extension
+- Better organization
+
+**Supported Types:**
+- 💬 Prompt (.txt)
+- 📝 Note (.md)
+- 🐍 Python (.py)
+- 📜 JavaScript (.js)
+- 📐 LaTeX (.tex)
+- 🗄️ SQL (.sql)
+- 💻 Bash (.sh)
+- ⚙️ Function (.txt)
+- 🌐 HTML (.html)
+- 🎨 CSS (.css)
+- 📄 Other (.txt)
+
+**How to Use:**
+1. When adding or editing, select content type
+2. Type appears with icon in table view
+3. File extension is automatically set
+
+---
+
+### 8. ✅ Title Field (Optional)
+**New Feature:**
+- Optional title field for better identification
+- Auto-generates from first 50 characters if left empty
+- Makes browsing easier
+
+**How to Use:**
+1. Leave empty for auto-generation
+2. OR enter custom title for important items
+
+---
+
+### 9. ✅ Better Statistics
+**Improvements:**
+- Now shows breakdown by content type
+- Shows type icons
+- More informative
+
+---
+
+## 🔧 All Fixed Issues
+
+### Fixed: Category/Section Renaming
+- ✅ Can now rename without creating duplicates
+- ✅ All related items update automatically
+- ✅ No orphaned data
+
+### Fixed: Bulk Operations
+- ✅ Can delete entire category
+- ✅ Can delete entire section
+- ✅ Confirmation prevents accidents
+
+### Fixed: Section Dropdown
+- ✅ Filters by selected category
+- ✅ Only shows relevant sections
+- ✅ Much cleaner UX
+
+### Fixed: Search UX
+- ✅ Auto-filtering (no search button)
+- ✅ Instant feedback
+- ✅ Better responsiveness
+
+### Fixed: Content Viewing
+- ✅ Easy copy functionality
+- ✅ Content preview panel
+- ✅ Copy button for convenience
+
+### Fixed: Table Display
+- ✅ Fixed height with scrolling
+- ✅ Consistent interface size
+- ✅ Better navigation
+
+---
+
+## 📊 Database Migration Details
+
+### What Happens Automatically:
+1. App detects old `prompts.db`
+2. Creates new `textarchive.db` schema
+3. Copies all data:
+   - `id` → `id`
+   - `category` → `category`
+   - `section` → `section`
+   - `prompt_text` → `content`
+   - First 50 chars → `title`
+   - Sets `content_type` to "prompt"
+   - Sets `file_extension` to ".txt"
+   - Preserves timestamps
+
+### Your Data is Safe:
+- Old `prompts.db` is NOT deleted
+- You can keep both files as backup
+- All data is preserved
+
+---
+
+## 🎯 Comparison: Old vs New
+
+| Feature | Old (Prompt Manager) | New (TextArchive) |
+|---------|---------------------|-------------------|
+| **Content Types** | Prompts only | 11 types (prompts, code, notes, etc.) |
+| **Rename Category** | ❌ Creates duplicate | ✅ Updates all items |
+| **Rename Section** | ❌ Creates duplicate | ✅ Updates all items |
+| **Delete Category** | ❌ One by one only | ✅ Bulk delete with confirm |
+| **Delete Section** | ❌ One by one only | ✅ Bulk delete with confirm |
+| **Section Filter** | Shows all sections | ✅ Filters by category |
+| **Search** | Click button | ✅ Auto-updates (AJAX) |
+| **Copy Content** | Copy whole row | ✅ Copy button for text only |
+| **Table Size** | Grows indefinitely | ✅ Fixed with scrolling |
+| **Title Field** | ❌ Not available | ✅ Optional with auto-gen |
+| **Statistics** | Basic | ✅ Enhanced with types |
+
+---
+
+## 🚀 Quick Start Guide
+
+### If You're New:
+1. Go to "Add New Item" tab
+2. Enter category, section, choose type
+3. Enter content
+4. Click "Add Item"
+5. Done!
+
+### If You're Migrating:
+1. Run the new app
+2. Your data automatically migrates
+3. Explore new "Manage Categories & Sections" tab
+4. Try the new auto-filtering
+5. Enjoy easy content copying!
+
+---
+
+## 💡 Pro Tips
+
+### Tip 1: Use Content Types
+- Organize code separately from prompts
+- Use "note" type for documentation
+- Use proper types for better organization
+
+### Tip 2: Rename Instead of Recreate
+- Use the rename feature in "Manage" tab
+- Don't create new category/section with similar name
+- Keeps data clean and organized
+
+### Tip 3: Use the Content Preview
+- Click row to see full content
+- Use copy button for quick copying
+- No need to edit just to copy
+
+### Tip 4: Take Advantage of Auto-Filtering
+- Set category filter
+- Section dropdown automatically shows only relevant sections
+- Quick way to navigate large collections
+
+### Tip 5: Regular Backups
+- Periodically backup `textarchive.db`
+- Keep old `prompts.db` as safety net
+- Export important items
+
+---
+
+## ❓ FAQ
+
+**Q: Will I lose my old data?**
+A: No! The app automatically migrates your data from `prompts.db` to `textarchive.db`. Both files are kept.
+
+**Q: Can I still use it just for prompts?**
+A: Absolutely! Just always select "prompt" as content type. Works exactly like before, with bonus features.
+
+**Q: What if I have duplicate category names?**
+A: The new system handles case-sensitive duplicates better. Use the rename feature to consolidate.
+
+**Q: Can I undo a bulk delete?**
+A: No, that's why confirmation is required. Always backup your database before major deletions.
+
+**Q: Do I need to click "Search" anymore?**
+A: No! Filters update automatically. Just select your filters and the table updates instantly.
+
+**Q: How do I copy just the text content?**
+A: Click on a row → Content appears in preview → Click copy button (or select and Ctrl+C)
+
+**Q: Can I have the same section name in different categories?**
+A: Yes! Sections are independent. "General" can exist in both "Coding" and "Writing".
+
+---
+
+## 🎊 Conclusion
+
+TextArchive is a major upgrade that:
+- ✅ Fixes all critical issues
+- ✅ Adds powerful new features
+- ✅ Maintains backward compatibility
+- ✅ Improves user experience significantly
+
+Your old data is safe and automatically migrated. You can now manage text content of any type with powerful organization and management tools!
+
+Enjoy your new TextArchive! 🚀

README.md

@@ -1,78 +1,315 @@
-# TextArchive
+---
+title: TextArchive
+emoji: 📚
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+python_version: "3.11"
+app_file: app.py
+pinned: false
+---
 
-**True 3-way sync** between:
-- **Local**: E:\HuggingFace\TextArchive
-- **GitHub**: https://github.com/mnoorchenar/TextArchive
-- **Hugging Face**: https://huggingface.co/spaces/mnoorchenar/TextArchive
+# TextArchive - Universal Text Management System
 
-## Project Structure
+A powerful and intuitive web application for managing all your text-based content with a clear hierarchical structure: **Category → Section → Content Type → Content**.
 
-```
-TextArchive/
-├── templates/
-│   └── index.html
-├── app.py
-├── Dockerfile
-├── requirements.txt
-├── sync.ps1
-└── README.md
-```
+## 🎯 What is TextArchive?
 
-## Usage
+TextArchive is not just a prompt manager - it's a universal system for organizing ANY text-based content:
+- 💬 Prompts for AI models
+- 📝 Notes and documentation
+- 🐍 Code snippets (Python, JavaScript, SQL, etc.)
+- 📐 LaTeX documents
+- 💻 Bash scripts
+- ⚙️ Functions and utilities
+- 🌐 HTML/CSS templates
+- 📄 Any other text content
 
-**Push changes (auto-merges from both remotes first):**
-```powershell
-.\sync.ps1 "Your commit message"
-```
+## 📐 Organization Structure
 
-**Pull latest without pushing:**
-```powershell
-.\sync.ps1 -PullOnly
-```
+Your content is organized in a clear three-level hierarchy:
+- **Category** (High-level grouping) - e.g., "Coding", "Writing", "Research"
+- **Section** (Subsection under category) - e.g., "Python", "JavaScript", "Blog Posts"
+- **Content Type** (What kind of content) - e.g., "python", "note", "prompt", "latex"
+- **Content** (Your actual text)
 
-**Auto-sync (default message):**
-```powershell
-.\sync.ps1
+Example hierarchy:
 ```
+📁 Coding (Category)
+   └── 📄 Python (Section)
+       └── 🐍 Python Code: "Function to calculate fibonacci..."
+       └── 💬 Prompt: "Write a Python function that..."
+   └── 📄 JavaScript (Section)
+       └── 📜 JavaScript: "React component for login..."
 
-**Debug mode:**
-```powershell
-.\sync.ps1 -Verbose
+📁 Research (Category)
+   └── 📄 AI Papers (Section)
+       └── 📝 Note: "Summary of transformer architecture..."
+       └── 📐 LaTeX: "\documentclass{article}..."
 ```
 
-## How It Works
+## ✨ Features
+
+### Core Functionality
+- ✅ **Add New Items**: Create content with custom categories, sections, and types
+- 📋 **View All Items**: See all your content organized hierarchically
+- 🔍 **Auto-Filter**: Filters update automatically (AJAX-style, no search button needed)
+- 📄 **Easy Copy**: Click any row to preview, then use the copy button to copy just the text content
+- ✏️ **Edit Items**: Click any item to edit its details
+- 🗑️ **Delete Items**: Remove items you no longer need
+- 🎯 **Fixed Height Table**: Scrollable table maintains consistent size
+- 💾 **Persistent Storage**: SQLite database stores all your data
+
+### Advanced Management
+- 🔄 **Rename Categories**: Rename categories and automatically update all items
+- 🔄 **Rename Sections**: Rename sections across all categories or within a specific category
+- 🗑️ **Bulk Delete**: Delete entire categories or sections at once (with confirmation)
+- 📊 **Statistics**: View insights about your content collection
+- 🏷️ **11 Content Types**: Prompt, Note, Python, JavaScript, LaTeX, SQL, Bash, Function, HTML, CSS, Other
+
+### Smart UX
+- 🎯 **Filtered Dropdowns**: Section dropdown automatically filters by selected category
+- 🔄 **Auto-Refresh**: All dropdowns update automatically after changes
+- ⚠️ **Confirmation Dialogs**: Destructive actions require confirmation
+- 📦 **Auto-Generated Titles**: Leave title empty to auto-generate from content
+- 🎨 **Type Icons**: Visual icons for each content type
+
+## 🚀 How to Use
+
+### Adding Content
+1. Go to the "➕ Add New Item" tab
+2. Select or type a **Category** (high-level grouping)
+3. Select or type a **Section** (subsection - dropdown auto-filters by category)
+4. Choose **Content Type** (prompt, note, python, etc.)
+5. (Optional) Enter a **Title** or leave empty for auto-generation
+6. Enter your **Content**
+7. Click "Add Item"
+
+### Viewing and Filtering Content
+1. Go to the "📋 View & Manage Items" tab
+2. Use filters to narrow down items:
+   - **Filter by Category**: Auto-updates table
+   - **Filter by Section**: Auto-updates table (filtered by category)
+   - **Filter by Type**: Auto-updates table
+3. Click "Clear Filters" to reset
+
+### Copying Content
+1. In the "View & Manage Items" tab, click on any row in the table
+2. The content appears in the **Content Preview** box below
+3. Click the **copy button** (📋) in the preview box, OR
+4. Click in the text box and press Ctrl+A (select all), then Ctrl+C (copy)
+5. Only the text content is copied - NO ID, category, or section included!
+
+### Editing Content
+1. Click on a row in the table to load it
+2. The item loads in the editing section below
+3. Modify Category, Section, Type, Title, or Content as needed
+4. Click "💾 Update Item" to save changes
 
-This script performs **TRUE 3-way synchronization**:
+### Deleting Content
+1. Click on a row to select it
+2. Click the "🗑️ Delete Item" button
+3. The item will be removed immediately
 
-1. **Fetches** from both GitHub and Hugging Face
-2. **Merges** changes from BOTH remotes (not just the newest)
-3. **Commits** your local changes
-4. **Pushes** to both remotes
+### Managing Categories & Sections
+1. Go to the "⚙️ Manage Categories & Sections" tab
 
-### Key Features
+**Rename Category:**
+- Select the category to rename
+- Enter new name
+- Click "🔄 Rename Category"
+- All items in that category will be updated
 
-✓ **Never loses commits** - merges from both remotes instead of overwriting
-✓ **Conflict handling** - keeps your local version if merge conflicts occur
-✓ **Smart detection** - only pushes when there are actual changes
-✓ **Status display** - shows timestamps from both remotes
+**Rename Section:**
+- (Optional) Select a category to limit scope
+- Select the section to rename
+- Enter new name
+- Click "🔄 Rename Section"
 
-### Example Workflow
+**Delete Category:**
+- Select the category
+- Check the confirmation box
+- Click "🗑️ Delete Category"
+- ALL items in that category will be deleted
 
-```powershell
-# Someone updates GitHub, someone else updates HuggingFace
-# Run sync - it merges BOTH changes:
-.\sync.ps1 "My local changes"
+**Delete Section:**
+- (Optional) Select a category to limit scope
+- Select the section
+- Check the confirmation box
+- Click "🗑️ Delete Section"
 
-# Output:
-# ✓ Merged from GitHub
-# ✓ Merged from HuggingFace
-# ✓ Committed: My local changes
-# ✓ GitHub
-# ✓ Hugging Face
+### Viewing Statistics
+1. Go to the "📊 Statistics" tab
+2. View total counts, top categories, and breakdown by type
+3. Click "🔄 Refresh Statistics" to update
+
+## 🎨 Content Types
+
+TextArchive supports 11 content types, each with its own icon and file extension:
+
+| Type | Icon | Extension | Use For |
+|------|------|-----------|---------|
+| prompt | 💬 | .txt | AI prompts and instructions |
+| note | 📝 | .md | Notes and documentation |
+| python | 🐍 | .py | Python code and scripts |
+| javascript | 📜 | .js | JavaScript code |
+| latex | 📐 | .tex | LaTeX documents |
+| sql | 🗄️ | .sql | SQL queries and scripts |
+| bash | 💻 | .sh | Bash shell scripts |
+| function | ⚙️ | .txt | Reusable functions |
+| html | 🌐 | .html | HTML markup |
+| css | 🎨 | .css | CSS stylesheets |
+| other | 📄 | .txt | Any other text content |
+
+## 🔧 Technical Details
+
+- **Framework**: Gradio 4.44.0+
+- **Database**: SQLite (automatically created as `textarchive.db`)
+- **Python**: 3.8+
+- **Auto-Migration**: Automatically migrates from old `prompts.db` if exists
+
+## 📊 Database Schema
+
+```sql
+CREATE TABLE text_items (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    category TEXT NOT NULL,
+    section TEXT NOT NULL,
+    title TEXT NOT NULL,
+    content TEXT NOT NULL,
+    content_type TEXT DEFAULT 'prompt',
+    file_extension TEXT DEFAULT '.txt',
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
 ```
 
-## Important Notes
+Indexes are created on `category`, `section`, and `content_type` for optimal performance.
+
+## 🚀 Deployment to Hugging Face Spaces
+
+### Method 1: Direct Upload
+
+1. Create a new Space on Hugging Face:
+   - Go to https://huggingface.co/new-space
+   - Choose "Gradio" as the SDK
+   - Set visibility (Public or Private)
+
+2. Upload these files to your Space:
+   - `app.py`
+   - `requirements.txt`
+   - `README.md` (optional)
+
+3. Your app will automatically deploy!
+
+### Method 2: Git (With Your Sync Script)
+
+1. Initialize your local repository:
+   ```bash
+   git init
+   git add .
+   git commit -m "Initial commit"
+   ```
+
+2. Add remotes:
+   ```bash
+   # Add GitHub remote
+   git remote add github https://github.com/YOUR_USERNAME/textarchive.git
+   
+   # Add Hugging Face remote
+   git remote add huggingface https://huggingface.co/spaces/YOUR_USERNAME/textarchive
+   ```
+
+3. Use your sync script:
+   ```powershell
+   # Set your Hugging Face token
+   $env:HF_TOKEN = "your_hf_token_here"
+   
+   # Run sync
+   .\sync.ps1 "Initial deployment"
+   ```
+
+## 🔄 Migration from Old "Prompt Manager"
+
+If you have an existing `prompts.db` from the old Prompt Manager:
+
+1. **Automatic Migration**: Just run the new app - it will automatically:
+   - Detect the old `prompts.db`
+   - Create the new `textarchive.db` schema
+   - Migrate all your data
+   - Set content_type to "prompt" for all old items
+   - Generate titles from the first 50 characters
+
+2. **Manual Backup** (Recommended):
+   ```bash
+   # Backup your old database first
+   cp prompts.db prompts.db.backup
+   ```
+
+3. **Verify Migration**:
+   - Open the app
+   - Go to Statistics tab
+   - Check that all items were migrated
+   - Check a few items to ensure content is intact
+
+## 📝 Notes
+
+- The database file persists between sessions
+- All users share the same database (unless you add authentication)
+- Backup your `textarchive.db` file regularly
+- Section dropdowns auto-filter by selected category for better UX
+- Auto-filtering eliminates the need for a search button
+- Fixed-height table with scrolling maintains clean interface
+
+## 🎯 Use Cases
+
+### For Developers
+- Store code snippets and functions
+- Organize SQL queries by project
+- Keep bash scripts and automation tools
+- Document API endpoints
+
+### For Writers
+- Organize story prompts and ideas
+- Store article outlines
+- Keep writing templates
+- Manage blog post drafts
+
+### For Researchers
+- Store LaTeX document snippets
+- Organize research notes by topic
+- Keep citation templates
+- Document methodologies
+
+### For AI/ML Engineers
+- Organize prompts by use case
+- Store fine-tuning examples
+- Document model configurations
+- Keep evaluation templates
+
+## 🔮 Future Enhancements (Suggestions)
+
+- Export individual items as files
+- Export category/section as ZIP
+- Import from files/folders
+- Tags system for cross-category organization
+- Full-text search within content
+- Syntax highlighting in preview
+- Markdown rendering for notes
+- Version history for items
+- User authentication for private libraries
+- API access for programmatic usage
+- Favorites/bookmarks
+- Sharing capabilities
+
+## 📜 License
+
+MIT License - Feel free to modify and use as needed!
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit issues or pull requests.
+
+---
 
-⚠️ **Git does NOT preserve file timestamps** - only commit timestamps are tracked
-⚠️ Files will have current timestamp after pull/clone, not original creation date
-⚠️ If you need file metadata preserved, consider using rsync instead
+**Built with ❤️ using Gradio and SQLite**

app.py

@@ -1,10 +1,818 @@
-from flask import Flask, render_template
+# TextArchive - Universal Text Management System
+import gradio as gr
+import sqlite3
+import pandas as pd
+from datetime import datetime
+import os
+import json
 
-app = Flask(__name__)
+# Database setup
+DB_PATH = "textarchive.db"
 
-@app.route('/')
-def home():
-    return render_template('index.html')
+# Content types supported
+CONTENT_TYPES = {
+    "prompt": {"extension": ".txt", "icon": "💬", "label": "Prompt"},
+    "note": {"extension": ".md", "icon": "📝", "label": "Note"},
+    "python": {"extension": ".py", "icon": "🐍", "label": "Python Code"},
+    "javascript": {"extension": ".js", "icon": "📜", "label": "JavaScript"},
+    "latex": {"extension": ".tex", "icon": "📐", "label": "LaTeX"},
+    "sql": {"extension": ".sql", "icon": "🗄️", "label": "SQL"},
+    "bash": {"extension": ".sh", "icon": "💻", "label": "Bash Script"},
+    "function": {"extension": ".txt", "icon": "⚙️", "label": "Function"},
+    "html": {"extension": ".html", "icon": "🌐", "label": "HTML"},
+    "css": {"extension": ".css", "icon": "🎨", "label": "CSS"},
+    "other": {"extension": ".txt", "icon": "📄", "label": "Other"}
+}
 
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860)
+def init_db():
+    """Initialize the database with text_items table"""
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    # Check if old table exists and migrate
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='prompts'")
+    old_table_exists = cursor.fetchone() is not None
+    
+    # Create new table
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS text_items (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            category TEXT NOT NULL,
+            section TEXT NOT NULL,
+            title TEXT NOT NULL,
+            content TEXT NOT NULL,
+            content_type TEXT DEFAULT 'prompt',
+            file_extension TEXT DEFAULT '.txt',
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    
+    # Migrate data from old table if exists
+    if old_table_exists:
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='text_items'")
+        new_table_exists = cursor.fetchone() is not None
+        
+        if new_table_exists:
+            cursor.execute("SELECT COUNT(*) FROM text_items")
+            if cursor.fetchone()[0] == 0:  # Only migrate if new table is empty
+                cursor.execute('''
+                    INSERT INTO text_items (id, category, section, title, content, content_type, file_extension, created_at, updated_at)
+                    SELECT id, category, section, 
+                           substr(prompt_text, 1, 50) as title,
+                           prompt_text as content,
+                           'prompt' as content_type,
+                           '.txt' as file_extension,
+                           created_at, updated_at
+                    FROM prompts
+                ''')
+    
+    # Create indexes
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_category ON text_items(category)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_section ON text_items(section)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_content_type ON text_items(content_type)")
+    
+    conn.commit()
+    conn.close()
+
+def get_unique_categories():
+    """Get all unique categories from the database"""
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("SELECT DISTINCT category FROM text_items ORDER BY category")
+    categories = [row[0] for row in cursor.fetchall()]
+    conn.close()
+    return categories
+
+def get_sections_by_category(category):
+    """Get sections for a specific category"""
+    if not category or category.strip() == "":
+        return []
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("SELECT DISTINCT section FROM text_items WHERE category=? ORDER BY section", (category,))
+    sections = [row[0] for row in cursor.fetchall()]
+    conn.close()
+    return sections
+
+def get_all_unique_sections():
+    """Get all unique sections from the database"""
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("SELECT DISTINCT section FROM text_items ORDER BY section")
+    sections = [row[0] for row in cursor.fetchall()]
+    conn.close()
+    return sections
+
+def add_text_item(category, section, title, content, content_type):
+    """Add a new text item to the database"""
+    if not category or not section or not content:
+        return "❌ Error: Category, Section, and Content are required!", search_text_items("", "", ""), gr.Dropdown(choices=get_unique_categories()), gr.Dropdown(choices=[])
+    
+    # Use first 50 chars of content as title if title is empty
+    if not title or title.strip() == "":
+        title = content.strip()[:50] + ("..." if len(content.strip()) > 50 else "")
+    
+    # Get file extension from content type
+    file_ext = CONTENT_TYPES.get(content_type, CONTENT_TYPES["other"])["extension"]
+    
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute(
+        "INSERT INTO text_items (category, section, title, content, content_type, file_extension) VALUES (?, ?, ?, ?, ?, ?)",
+        (category.strip(), section.strip(), title.strip(), content.strip(), content_type, file_ext)
+    )
+    conn.commit()
+    conn.close()
+    
+    return "✅ Item added successfully!", search_text_items("", "", ""), gr.Dropdown(choices=get_unique_categories()), gr.Dropdown(choices=get_sections_by_category(category))
+
+def search_text_items(category_filter, section_filter, type_filter):
+    """Search text items by category, section, and/or content type"""
+    conn = sqlite3.connect(DB_PATH)
+    
+    query = "SELECT id, category, section, title, content, content_type, created_at, updated_at FROM text_items WHERE 1=1"
+    params = []
+    
+    if category_filter and category_filter.strip():
+        query += " AND category = ?"
+        params.append(category_filter.strip())
+    
+    if section_filter and section_filter.strip():
+        query += " AND section = ?"
+        params.append(section_filter.strip())
+    
+    if type_filter and type_filter.strip() and type_filter != "All Types":
+        query += " AND content_type = ?"
+        params.append(type_filter.strip())
+    
+    query += " ORDER BY category, section, updated_at DESC"
+    
+    df = pd.read_sql_query(query, conn, params=params)
+    conn.close()
+    
+    # Add icon to content type for display
+    if not df.empty:
+        df['Type'] = df['content_type'].apply(lambda x: f"{CONTENT_TYPES.get(x, CONTENT_TYPES['other'])['icon']} {CONTENT_TYPES.get(x, CONTENT_TYPES['other'])['label']}")
+        # Reorder columns for better display (hide content in table view)
+        df = df[['id', 'category', 'section', 'Type', 'title', 'created_at', 'updated_at']]
+    
+    return df
+
+def get_content_by_id(item_id):
+    """Get the full content of a specific item by ID"""
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("SELECT content FROM text_items WHERE id=?", (item_id,))
+    result = cursor.fetchone()
+    conn.close()
+    return result[0] if result else ""
+
+def update_text_item(item_id, category, section, title, content, content_type):
+    """Update an existing text item"""
+    if not item_id:
+        return "❌ Error: Please select an item to update!", search_text_items("", "", ""), gr.Dropdown(choices=get_unique_categories()), gr.Dropdown(choices=[])
+    
+    if not category or not section or not content:
+        return "❌ Error: Category, Section, and Content are required!", search_text_items("", "", ""), gr.Dropdown(choices=get_unique_categories()), gr.Dropdown(choices=[])
+    
+    # Use first 50 chars of content as title if title is empty
+    if not title or title.strip() == "":
+        title = content.strip()[:50] + ("..." if len(content.strip()) > 50 else "")
+    
+    # Get file extension from content type
+    file_ext = CONTENT_TYPES.get(content_type, CONTENT_TYPES["other"])["extension"]
+    
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute(
+        "UPDATE text_items SET category=?, section=?, title=?, content=?, content_type=?, file_extension=?, updated_at=CURRENT_TIMESTAMP WHERE id=?",
+        (category.strip(), section.strip(), title.strip(), content.strip(), content_type, file_ext, item_id)
+    )
+    conn.commit()
+    conn.close()
+    return "✅ Item updated successfully!", search_text_items("", "", ""), gr.Dropdown(choices=get_unique_categories()), gr.Dropdown(choices=get_sections_by_category(category))
+
+def delete_text_item(item_id):
+    """Delete a text item from the database"""
+    if not item_id:
+        return "❌ Error: Please select an item to delete!", search_text_items("", "", ""), gr.Dropdown(choices=get_unique_categories()), gr.Dropdown(choices=[])
+    
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("DELETE FROM text_items WHERE id=?", (item_id,))
+    conn.commit()
+    conn.close()
+    return "✅ Item deleted successfully!", search_text_items("", "", ""), gr.Dropdown(choices=get_unique_categories()), gr.Dropdown(choices=[])
+
+def load_item_for_editing(items_df, evt: gr.SelectData):
+    """Load selected item data for editing"""
+    if items_df is None or items_df.empty:
+        return None, "", "", "", "", "prompt"
+    
+    row_index = evt.index[0]
+    row = items_df.iloc[row_index]
+    item_id = row['id']
+    
+    # Get full content from database
+    content = get_content_by_id(item_id)
+    
+    # Extract content_type from Type column (remove icon)
+    type_display = row['Type']
+    content_type = next((k for k, v in CONTENT_TYPES.items() if v['label'] in type_display), 'other')
+    
+    return item_id, row['category'], row['section'], row['title'], content, content_type
+
+def rename_category(old_name, new_name):
+    """Rename a category (updates all items with that category)"""
+    if not old_name or not new_name:
+        return "❌ Error: Both old and new category names are required!", search_text_items("", "", "")
+    
+    if old_name.strip() == new_name.strip():
+        return "❌ Error: New name must be different from old name!", search_text_items("", "", "")
+    
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    # Check how many items will be affected
+    cursor.execute("SELECT COUNT(*) FROM text_items WHERE category=?", (old_name.strip(),))
+    count = cursor.fetchone()[0]
+    
+    if count == 0:
+        conn.close()
+        return f"❌ Error: Category '{old_name}' not found!", search_text_items("", "", "")
+    
+    # Perform the rename
+    cursor.execute(
+        "UPDATE text_items SET category=?, updated_at=CURRENT_TIMESTAMP WHERE category=?",
+        (new_name.strip(), old_name.strip())
+    )
+    conn.commit()
+    conn.close()
+    
+    return f"✅ Category renamed! {count} items updated from '{old_name}' to '{new_name}'", search_text_items("", "", "")
+
+def rename_section(category, old_name, new_name):
+    """Rename a section within a category (updates all items with that section)"""
+    if not old_name or not new_name:
+        return "❌ Error: Both old and new section names are required!", search_text_items("", "", "")
+    
+    if old_name.strip() == new_name.strip():
+        return "❌ Error: New name must be different from old name!", search_text_items("", "", "")
+    
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    # Build query based on whether category is specified
+    if category and category.strip():
+        cursor.execute("SELECT COUNT(*) FROM text_items WHERE category=? AND section=?", 
+                      (category.strip(), old_name.strip()))
+        count = cursor.fetchone()[0]
+        
+        if count == 0:
+            conn.close()
+            return f"❌ Error: Section '{old_name}' not found in category '{category}'!", search_text_items("", "", "")
+        
+        cursor.execute(
+            "UPDATE text_items SET section=?, updated_at=CURRENT_TIMESTAMP WHERE category=? AND section=?",
+            (new_name.strip(), category.strip(), old_name.strip())
+        )
+    else:
+        cursor.execute("SELECT COUNT(*) FROM text_items WHERE section=?", (old_name.strip(),))
+        count = cursor.fetchone()[0]
+        
+        if count == 0:
+            conn.close()
+            return f"❌ Error: Section '{old_name}' not found!", search_text_items("", "", "")
+        
+        cursor.execute(
+            "UPDATE text_items SET section=?, updated_at=CURRENT_TIMESTAMP WHERE section=?",
+            (new_name.strip(), old_name.strip())
+        )
+    
+    conn.commit()
+    conn.close()
+    
+    return f"✅ Section renamed! {count} items updated from '{old_name}' to '{new_name}'", search_text_items("", "", "")
+
+def delete_by_category(category, confirm=False):
+    """Delete all items in a category"""
+    if not category or not category.strip():
+        return "❌ Error: Category is required!", search_text_items("", "", "")
+    
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    # Get count
+    cursor.execute("SELECT COUNT(*) FROM text_items WHERE category=?", (category.strip(),))
+    count = cursor.fetchone()[0]
+    
+    if count == 0:
+        conn.close()
+        return f"❌ Error: Category '{category}' not found or is empty!", search_text_items("", "", "")
+    
+    if not confirm:
+        conn.close()
+        return f"⚠️ Warning: This will delete {count} items in category '{category}'. Click again to confirm!", search_text_items("", "", "")
+    
+    # Perform deletion
+    cursor.execute("DELETE FROM text_items WHERE category=?", (category.strip(),))
+    conn.commit()
+    conn.close()
+    
+    return f"✅ Category deleted! {count} items removed from '{category}'", search_text_items("", "", "")
+
+def delete_by_section(category, section, confirm=False):
+    """Delete all items in a section"""
+    if not section or not section.strip():
+        return "❌ Error: Section is required!", search_text_items("", "", "")
+    
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    # Build query based on whether category is specified
+    if category and category.strip():
+        cursor.execute("SELECT COUNT(*) FROM text_items WHERE category=? AND section=?", 
+                      (category.strip(), section.strip()))
+        count = cursor.fetchone()[0]
+        
+        if count == 0:
+            conn.close()
+            return f"❌ Error: Section '{section}' not found in category '{category}' or is empty!", search_text_items("", "", "")
+        
+        if not confirm:
+            conn.close()
+            return f"⚠️ Warning: This will delete {count} items in section '{section}' under '{category}'. Click again to confirm!", search_text_items("", "", "")
+        
+        cursor.execute("DELETE FROM text_items WHERE category=? AND section=?", 
+                      (category.strip(), section.strip()))
+    else:
+        cursor.execute("SELECT COUNT(*) FROM text_items WHERE section=?", (section.strip(),))
+        count = cursor.fetchone()[0]
+        
+        if count == 0:
+            conn.close()
+            return f"❌ Error: Section '{section}' not found or is empty!", search_text_items("", "", "")
+        
+        if not confirm:
+            conn.close()
+            return f"⚠️ Warning: This will delete {count} items in section '{section}' (across all categories). Click again to confirm!", search_text_items("", "", "")
+        
+        cursor.execute("DELETE FROM text_items WHERE section=?", (section.strip(),))
+    
+    conn.commit()
+    conn.close()
+    
+    return f"✅ Section deleted! {count} items removed from '{section}'", search_text_items("", "", "")
+
+# Initialize database
+init_db()
+
+# Create Gradio interface
+with gr.Blocks(title="TextArchive", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 📚 TextArchive - Universal Text Management System")
+    gr.Markdown("Organize your text content: **Category** (high-level) → **Section** (subsection) → **Content**")
+    
+    with gr.Tabs():
+        # Add New Item Tab
+        with gr.Tab("➕ Add New Item"):
+            gr.Markdown("### Add a New Text Item")
+            gr.Markdown("💡 **Hierarchy**: Category → Section → Content Type → Content")
+            with gr.Row():
+                with gr.Column():
+                    new_category = gr.Dropdown(
+                        label="Category (High-Level)",
+                        choices=get_unique_categories(),
+                        allow_custom_value=True,
+                        info="Enter a new category or select existing"
+                    )
+                    new_section = gr.Dropdown(
+                        label="Section (Subsection)",
+                        choices=[],
+                        allow_custom_value=True,
+                        info="Enter a new section or select existing"
+                    )
+                    new_content_type = gr.Dropdown(
+                        label="Content Type",
+                        choices=list(CONTENT_TYPES.keys()),
+                        value="prompt",
+                        info="Select the type of content"
+                    )
+                    new_title = gr.Textbox(
+                        label="Title (Optional)",
+                        placeholder="Leave empty to auto-generate from content...",
+                        lines=1
+                    )
+                    new_content = gr.Textbox(
+                        label="Content",
+                        placeholder="Enter your content here...",
+                        lines=12
+                    )
+                    add_btn = gr.Button("➕ Add Item", variant="primary", size="lg")
+                    add_status = gr.Textbox(label="Status", interactive=False)
+        
+        # View & Manage Items Tab
+        with gr.Tab("📋 View & Manage Items"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### 🔍 Filter (Auto-updates)")
+                    filter_category = gr.Dropdown(
+                        label="Filter by Category",
+                        choices=[""] + get_unique_categories(),
+                        value="",
+                        allow_custom_value=False,
+                        info="Select category to filter"
+                    )
+                    filter_section = gr.Dropdown(
+                        label="Filter by Section",
+                        choices=[""],
+                        value="",
+                        allow_custom_value=False,
+                        info="Select section to filter"
+                    )
+                    filter_type = gr.Dropdown(
+                        label="Filter by Type",
+                        choices=["All Types"] + list(CONTENT_TYPES.keys()),
+                        value="All Types",
+                        info="Select content type"
+                    )
+                    clear_filter_btn = gr.Button("🔄 Clear Filters", variant="secondary")
+                
+                with gr.Column(scale=3):
+                    gr.Markdown("### All Items (Click row to view/edit)")
+                    items_display = gr.Dataframe(
+                        value=search_text_items("", "", ""),
+                        label="Text Items - Category → Section → Type → Title",
+                        interactive=False,
+                        wrap=True,
+                        height=400,  # Fixed height with scrolling
+                        column_widths=["5%", "15%", "15%", "15%", "35%", "15%"]
+                    )
+            
+            gr.Markdown("---")
+            
+            # Content Preview and Copy Section
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 📄 Content Preview")
+                    content_preview = gr.Textbox(
+                        label="Selected Content (Click to select all, then Ctrl+C to copy)",
+                        lines=8,
+                        interactive=True,
+                        show_copy_button=True
+                    )
+            
+            gr.Markdown("---")
+            gr.Markdown("### ✏️ Edit Selected Item")
+            
+            with gr.Row():
+                with gr.Column():
+                    edit_id = gr.Number(label="Item ID", visible=False)
+                    edit_category = gr.Dropdown(
+                        label="Category (High-Level)",
+                        choices=get_unique_categories(),
+                        allow_custom_value=True
+                    )
+                    edit_section = gr.Dropdown(
+                        label="Section (Subsection)",
+                        choices=[],
+                        allow_custom_value=True
+                    )
+                    edit_content_type = gr.Dropdown(
+                        label="Content Type",
+                        choices=list(CONTENT_TYPES.keys()),
+                        value="prompt"
+                    )
+                    edit_title = gr.Textbox(label="Title", lines=1)
+                    edit_content = gr.Textbox(label="Content", lines=10)
+                    
+                    with gr.Row():
+                        update_btn = gr.Button("💾 Update Item", variant="primary")
+                        delete_btn = gr.Button("🗑️ Delete Item", variant="stop")
+                    
+                    edit_status = gr.Textbox(label="Status", interactive=False)
+        
+        # Manage Categories & Sections Tab
+        with gr.Tab("⚙️ Manage Categories & Sections"):
+            gr.Markdown("### 🏷️ Rename or Delete Categories and Sections")
+            
+            with gr.Row():
+                # Rename Category
+                with gr.Column():
+                    gr.Markdown("#### Rename Category")
+                    rename_cat_old = gr.Dropdown(
+                        label="Select Category",
+                        choices=get_unique_categories(),
+                        allow_custom_value=False
+                    )
+                    rename_cat_new = gr.Textbox(
+                        label="New Category Name",
+                        placeholder="Enter new name..."
+                    )
+                    rename_cat_btn = gr.Button("🔄 Rename Category", variant="primary")
+                    rename_cat_status = gr.Textbox(label="Status", interactive=False)
+                
+                # Rename Section
+                with gr.Column():
+                    gr.Markdown("#### Rename Section")
+                    rename_sec_category = gr.Dropdown(
+                        label="Category (Optional)",
+                        choices=[""] + get_unique_categories(),
+                        allow_custom_value=False,
+                        info="Leave empty to rename across all categories"
+                    )
+                    rename_sec_old = gr.Dropdown(
+                        label="Select Section",
+                        choices=get_all_unique_sections(),
+                        allow_custom_value=False
+                    )
+                    rename_sec_new = gr.Textbox(
+                        label="New Section Name",
+                        placeholder="Enter new name..."
+                    )
+                    rename_sec_btn = gr.Button("🔄 Rename Section", variant="primary")
+                    rename_sec_status = gr.Textbox(label="Status", interactive=False)
+            
+            gr.Markdown("---")
+            
+            with gr.Row():
+                # Delete Category
+                with gr.Column():
+                    gr.Markdown("#### Delete Entire Category")
+                    gr.Markdown("⚠️ **Warning**: This will delete ALL items in the category!")
+                    delete_cat_select = gr.Dropdown(
+                        label="Select Category",
+                        choices=get_unique_categories(),
+                        allow_custom_value=False
+                    )
+                    delete_cat_confirm = gr.Checkbox(label="I understand this will delete all items", value=False)
+                    delete_cat_btn = gr.Button("🗑️ Delete Category", variant="stop")
+                    delete_cat_status = gr.Textbox(label="Status", interactive=False)
+                
+                # Delete Section
+                with gr.Column():
+                    gr.Markdown("#### Delete Entire Section")
+                    gr.Markdown("⚠️ **Warning**: This will delete ALL items in the section!")
+                    delete_sec_category = gr.Dropdown(
+                        label="Category (Optional)",
+                        choices=[""] + get_unique_categories(),
+                        allow_custom_value=False,
+                        info="Leave empty to delete across all categories"
+                    )
+                    delete_sec_select = gr.Dropdown(
+                        label="Select Section",
+                        choices=get_all_unique_sections(),
+                        allow_custom_value=False
+                    )
+                    delete_sec_confirm = gr.Checkbox(label="I understand this will delete all items", value=False)
+                    delete_sec_btn = gr.Button("🗑️ Delete Section", variant="stop")
+                    delete_sec_status = gr.Textbox(label="Status", interactive=False)
+        
+        # Statistics Tab
+        with gr.Tab("📊 Statistics"):
+            stats_display = gr.Markdown()
+            refresh_stats_btn = gr.Button("🔄 Refresh Statistics", variant="secondary")
+    
+    # Event handlers
+    def clear_filters():
+        return "", "", "All Types", search_text_items("", "", "")
+    
+    def get_statistics():
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+        
+        cursor.execute("SELECT COUNT(*) FROM text_items")
+        total = cursor.fetchone()[0]
+        
+        cursor.execute("SELECT COUNT(DISTINCT category) FROM text_items")
+        categories = cursor.fetchone()[0]
+        
+        cursor.execute("SELECT COUNT(DISTINCT section) FROM text_items")
+        sections = cursor.fetchone()[0]
+        
+        cursor.execute("SELECT category, COUNT(*) as count FROM text_items GROUP BY category ORDER BY count DESC LIMIT 10")
+        top_categories = cursor.fetchall()
+        
+        cursor.execute("SELECT content_type, COUNT(*) as count FROM text_items GROUP BY content_type ORDER BY count DESC")
+        by_type = cursor.fetchall()
+        
+        conn.close()
+        
+        stats = f"""
+## 📊 Database Statistics
+
+- **Total Items:** {total}
+- **Total Categories:** {categories}
+- **Total Sections:** {sections}
+
+---
+
+### 🏆 Top Categories by Item Count:
+"""
+        if top_categories:
+            for cat, count in top_categories:
+                stats += f"\n- **{cat}:** {count} items"
+        else:
+            stats += "\n*No data yet*"
+        
+        stats += "\n\n### 📝 Items by Content Type:\n"
+        if by_type:
+            for ctype, count in by_type:
+                icon = CONTENT_TYPES.get(ctype, CONTENT_TYPES['other'])['icon']
+                label = CONTENT_TYPES.get(ctype, CONTENT_TYPES['other'])['label']
+                stats += f"\n- {icon} **{label}:** {count} items"
+        else:
+            stats += "\n*No data yet*"
+        
+        return stats
+    
+    def update_section_choices_on_category_change(category):
+        """Update section dropdown when category changes"""
+        sections = get_sections_by_category(category) if category else []
+        return gr.Dropdown(choices=sections)
+    
+    def auto_filter(category, section, content_type):
+        """Automatically filter when any filter changes"""
+        return search_text_items(category, section, content_type)
+    
+    def update_content_preview(items_df, evt: gr.SelectData):
+        """Update content preview when row is selected"""
+        if items_df is None or items_df.empty:
+            return ""
+        
+        row_index = evt.index[0]
+        row = items_df.iloc[row_index]
+        item_id = row['id']
+        
+        # Get full content from database
+        content = get_content_by_id(item_id)
+        return content
+    
+    # Connect events for Add tab
+    new_category.change(
+        fn=update_section_choices_on_category_change,
+        inputs=[new_category],
+        outputs=[new_section]
+    )
+    
+    add_btn.click(
+        fn=add_text_item,
+        inputs=[new_category, new_section, new_title, new_content, new_content_type],
+        outputs=[add_status, items_display, new_category, new_section]
+    ).then(
+        fn=lambda: ("", "", ""),
+        outputs=[new_title, new_content, new_section]
+    ).then(
+        fn=lambda: [
+            gr.Dropdown(choices=get_unique_categories()),
+            gr.Dropdown(choices=[""] + get_unique_categories()),
+            gr.Dropdown(choices=get_unique_categories()),
+            gr.Dropdown(choices=[""] + get_unique_categories()),
+            gr.Dropdown(choices=get_unique_categories()),
+            gr.Dropdown(choices=get_unique_categories()),
+            gr.Dropdown(choices=[""] + get_unique_categories()),
+            gr.Dropdown(choices=get_unique_categories())
+        ],
+        outputs=[
+            new_category, filter_category, edit_category,
+            rename_sec_category, rename_cat_old,
+            delete_cat_select, delete_sec_category, rename_sec_category
+        ]
+    )
+    
+    # Auto-filter when any filter changes
+    filter_category.change(
+        fn=lambda cat: gr.Dropdown(choices=[""] + get_sections_by_category(cat)),
+        inputs=[filter_category],
+        outputs=[filter_section]
+    ).then(
+        fn=auto_filter,
+        inputs=[filter_category, filter_section, filter_type],
+        outputs=items_display
+    )
+    
+    filter_section.change(
+        fn=auto_filter,
+        inputs=[filter_category, filter_section, filter_type],
+        outputs=items_display
+    )
+    
+    filter_type.change(
+        fn=auto_filter,
+        inputs=[filter_category, filter_section, filter_type],
+        outputs=items_display
+    )
+    
+    clear_filter_btn.click(
+        fn=clear_filters,
+        outputs=[filter_category, filter_section, filter_type, items_display]
+    )
+    
+    # Load item for editing and preview when row is selected
+    items_display.select(
+        fn=load_item_for_editing,
+        inputs=[items_display],
+        outputs=[edit_id, edit_category, edit_section, edit_title, edit_content, edit_content_type]
+    )
+    
+    items_display.select(
+        fn=update_content_preview,
+        inputs=[items_display],
+        outputs=[content_preview]
+    )
+    
+    # Update section dropdown when edit category changes
+    edit_category.change(
+        fn=update_section_choices_on_category_change,
+        inputs=[edit_category],
+        outputs=[edit_section]
+    )
+    
+    update_btn.click(
+        fn=update_text_item,
+        inputs=[edit_id, edit_category, edit_section, edit_title, edit_content, edit_content_type],
+        outputs=[edit_status, items_display, edit_category, edit_section]
+    ).then(
+        fn=lambda: [
+            gr.Dropdown(choices=get_unique_categories()),
+            gr.Dropdown(choices=[""] + get_unique_categories())
+        ],
+        outputs=[new_category, filter_category]
+    )
+    
+    delete_btn.click(
+        fn=delete_text_item,
+        inputs=[edit_id],
+        outputs=[edit_status, items_display, edit_category, edit_section]
+    ).then(
+        fn=lambda: (None, "", "", "", "", "prompt"),
+        outputs=[edit_id, edit_category, edit_section, edit_title, edit_content, edit_content_type]
+    ).then(
+        fn=lambda: [
+            gr.Dropdown(choices=get_unique_categories()),
+            gr.Dropdown(choices=[""] + get_unique_categories())
+        ],
+        outputs=[new_category, filter_category]
+    )
+    
+    # Rename category
+    rename_cat_btn.click(
+        fn=rename_category,
+        inputs=[rename_cat_old, rename_cat_new],
+        outputs=[rename_cat_status, items_display]
+    ).then(
+        fn=lambda: [
+            gr.Dropdown(choices=get_unique_categories()),
+            gr.Dropdown(choices=get_unique_categories()),
+            gr.Dropdown(choices=[""] + get_unique_categories()),
+            gr.Dropdown(choices=get_unique_categories()),
+            "", ""
+        ],
+        outputs=[rename_cat_old, new_category, filter_category, edit_category, rename_cat_old, rename_cat_new]
+    )
+    
+    # Rename section
+    rename_sec_btn.click(
+        fn=rename_section,
+        inputs=[rename_sec_category, rename_sec_old, rename_sec_new],
+        outputs=[rename_sec_status, items_display]
+    ).then(
+        fn=lambda: ["", ""],
+        outputs=[rename_sec_old, rename_sec_new]
+    )
+    
+    # Delete category
+    delete_cat_btn.click(
+        fn=delete_by_category,
+        inputs=[delete_cat_select, delete_cat_confirm],
+        outputs=[delete_cat_status, items_display]
+    ).then(
+        fn=lambda: [
+            gr.Dropdown(choices=get_unique_categories()),
+            gr.Dropdown(choices=get_unique_categories()),
+            gr.Dropdown(choices=[""] + get_unique_categories()),
+            False, ""
+        ],
+        outputs=[delete_cat_select, new_category, filter_category, delete_cat_confirm, delete_cat_select]
+    )
+    
+    # Delete section
+    delete_sec_btn.click(
+        fn=delete_by_section,
+        inputs=[delete_sec_category, delete_sec_select, delete_sec_confirm],
+        outputs=[delete_sec_status, items_display]
+    ).then(
+        fn=lambda: [False, ""],
+        outputs=[delete_sec_confirm, delete_sec_select]
+    )
+    
+    refresh_stats_btn.click(
+        fn=get_statistics,
+        outputs=stats_display
+    )
+    
+    # Load initial statistics
+    app.load(fn=get_statistics, outputs=stats_display)
+
+if __name__ == "__main__":
+    app.launch()

requirements.txt

@@ -1 +1,2 @@
-flask==2.3.0
+gradio>=4.44.0
+pandas>=2.2.0

sync.ps1

@@ -37,7 +37,7 @@ if ($hfRemote -match 'huggingface\.co/spaces/([^/]+)/(.+?)(?:\.git)?$') {
   exit 1
 }
 
-Write-Host "`n=== 3-Way Sync: Local â†" GitHub â†" HF ===`n"
+Write-Host "`n=== 3-Way Sync: Local <-> GitHub <-> HF ===`n"
 
 function Get-RemoteCommit($remote) {
   $commit = git rev-parse "$remote/main" 2>$null
@@ -92,51 +92,48 @@ if (-not $isFirstPush) {
     Write-Host "Merging from GitHub..."
     
     if ($hasLocalChanges) {
-      # Commit local changes first
       git commit -m "Local changes before merge" 2>$null | Out-Null
     }
     
     git merge github/main --no-edit 2>&1 | Out-Null
     
     if ($LASTEXITCODE -ne 0) {
-      Write-Host "� Merge conflict with GitHub. Keeping local version..."
+      Write-Host "[!] Merge conflict with GitHub. Keeping local version..."
       git merge --abort 2>$null
-      # Keep local but note we couldn't merge
     } else {
-      Write-Host "âœ" Merged from GitHub"
+      Write-Host "[OK] Merged from GitHub"
     }
   }
   
   # Check if we need to merge HuggingFace
-  $localCommit = git rev-parse HEAD 2>$null  # Update after potential GitHub merge
+  $localCommit = git rev-parse HEAD 2>$null
   if ($hfExists -and $hfCommit -and $localCommit -ne $hfCommit) {
     Write-Host "Merging from HuggingFace..."
     
     git diff HEAD --quiet
     if ($LASTEXITCODE -ne 0) {
-      # Commit any pending changes before merge
       git commit -m "Local changes before HF merge" 2>$null | Out-Null
     }
     
     git merge huggingface/main --no-edit 2>&1 | Out-Null
     
     if ($LASTEXITCODE -ne 0) {
-      Write-Host "� Merge conflict with HuggingFace. Keeping local version..."
+      Write-Host "[!] Merge conflict with HuggingFace. Keeping local version..."
       git merge --abort 2>$null
     } else {
-      Write-Host "âœ" Merged from HuggingFace"
+      Write-Host "[OK] Merged from HuggingFace"
     }
   }
   
   # Check if everything is in sync
   $localCommit = git rev-parse HEAD 2>$null
   if ($ghCommit -and $hfCommit -and $localCommit -eq $ghCommit -and $localCommit -eq $hfCommit) {
-    Write-Host "âœ" All locations in sync"
+    Write-Host "[OK] All locations in sync"
   }
 }
 
 if ($PullOnly) {
-  Write-Host "`nâœ" Pull complete`n"
+  Write-Host "`n[OK] Pull complete`n"
   exit 0
 }
 
@@ -144,7 +141,7 @@ if ($PullOnly) {
 git diff HEAD --quiet
 if ($LASTEXITCODE -ne 0) {
   git commit -m $Message
-  Write-Host "âœ" Committed: $Message"
+  Write-Host "[OK] Committed: $Message"
 } else {
   # Check if we have commits to push
   $localCommit = git rev-parse HEAD 2>$null
@@ -154,18 +151,18 @@ if ($LASTEXITCODE -ne 0) {
     $ghCommit = Get-RemoteCommit "github"
     if ($localCommit -ne $ghCommit) { $needsPush = $true }
   } else {
-    $needsPush = $true  # First push
+    $needsPush = $true
   }
   
   if ($hfExists) {
     $hfCommit = Get-RemoteCommit "huggingface"
     if ($localCommit -ne $hfCommit) { $needsPush = $true }
   } else {
-    $needsPush = $true  # First push
+    $needsPush = $true
   }
   
   if (-not $needsPush) {
-    Write-Host "âœ" Already up-to-date, nothing to push`n"
+    Write-Host "`n[OK] Already up-to-date, nothing to push`n"
     exit 0
   }
 }
@@ -176,13 +173,13 @@ Write-Host "`nPushing to remotes..."
 # Push to GitHub
 git push github main 2>&1 | Out-Null
 if ($LASTEXITCODE -eq 0) {
-  Write-Host "âœ" GitHub"
+  Write-Host "[OK] GitHub"
 } else {
   git push github main --force 2>&1 | Out-Null
   if ($LASTEXITCODE -eq 0) {
-    Write-Host "âœ" GitHub (forced)"
+    Write-Host "[OK] GitHub (forced)"
   } else {
-    Write-Host "✗ GitHub failed"
+    Write-Host "[ERROR] GitHub failed"
   }
 }
 
@@ -197,9 +194,9 @@ if ($Verbose) {
 }
 
 if ($LASTEXITCODE -eq 0) {
-  Write-Host "âœ" Hugging Face: spaces/${hfUser}/${hfSpace}"
+  Write-Host "[OK] Hugging Face: spaces/${hfUser}/${hfSpace}"
 } else {
-  Write-Host "✗ Hugging Face FAILED!"
+  Write-Host "[ERROR] Hugging Face FAILED!"
   Write-Host "`nTroubleshooting:"
   Write-Host "1. Does the space exist? https://huggingface.co/spaces/${hfUser}/${hfSpace}"
   Write-Host "2. Is your token valid? (HF Settings > Access Tokens)"
@@ -208,4 +205,4 @@ if ($LASTEXITCODE -eq 0) {
   exit 1
 }
 
-Write-Host "`nâœ" Sync complete`n"
+Write-Host "`n[OK] Sync complete`n"