Upload app.py

app.py

@@ -0,0 +1,814 @@
+#!/usr/bin/env python3
+"""
+NZ Legislation Loophole Analysis - Hugging Face Spaces App
+
+Root-level app.py for Hugging Face Spaces deployment.
+Adapted for Spaces memory constraints and session-based caching.
+"""
+
+import streamlit as st
+import sys
+import os
+import warnings
+from pathlib import Path
+
+# Add current directory to Python path for imports
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+# Suppress warnings for cleaner output
+warnings.filterwarnings('ignore')
+
+# Import core modules with error handling for Spaces
+try:
+    from streamlit_app.core.cache_manager import CacheManager, get_cache_manager
+    from streamlit_app.core.text_processor import TextProcessor
+    from streamlit_app.core.llm_analyzer import LLMAnalyzer
+    from streamlit_app.core.dataset_builder import DatasetBuilder
+    from streamlit_app.utils.config import ConfigManager
+    from streamlit_app.utils.performance import PerformanceMonitor
+    from streamlit_app.utils.ui_helpers import UIHelpers
+except ImportError as e:
+    st.error(f"❌ Import Error: {e}")
+    st.error("Please ensure all required packages are installed.")
+    st.stop()
+
+# Configure page settings for Spaces
+st.set_page_config(
+    page_title="NZ Legislation Loophole Analyzer",
+    page_icon="⚖️",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    menu_items={
+        'Get Help': 'https://huggingface.co/spaces/your-space',
+        'Report a bug': 'https://github.com/your-repo/issues',
+        'About': '''
+        ## NZ Legislation Loophole Analyzer
+        AI-powered analysis of New Zealand legislation to identify
+        potential loopholes, ambiguities, and unintended consequences.
+
+        **Version:** 1.0.0 (Spaces Edition)
+        **Platform:** Hugging Face Spaces
+        **Built with:** Streamlit & Llama.cpp
+        '''
+    }
+)
+
+# Spaces-specific configuration
+SPACES_CONFIG = {
+    'max_memory_mb': 512,  # Conservative memory limit for Spaces
+    'cache_enabled': True,
+    'persistent_cache': False,  # Session-based only
+    'model_path': 'qwen3.gguf',  # Default model
+    'context_length': 4096,  # Smaller context for memory
+    'max_tokens': 2048,  # Smaller responses
+}
+
+def initialize_spaces_session():
+    """Initialize session state optimized for Spaces"""
+    if 'cache_manager' not in st.session_state:
+        # Initialize with Spaces-optimized settings
+        st.session_state.cache_manager = CacheManager(
+            max_memory_mb=SPACES_CONFIG['max_memory_mb'],
+            persistent=False,  # No persistent storage in Spaces
+            ttl_hours=1  # Shorter TTL for memory efficiency
+        )
+
+    if 'config_manager' not in st.session_state:
+        st.session_state.config_manager = ConfigManager()
+
+        # Override with Spaces-optimized defaults
+        spaces_defaults = {
+            'model': {
+                'path': SPACES_CONFIG['model_path'],
+                'context_length': SPACES_CONFIG['context_length'],
+                'max_tokens': SPACES_CONFIG['max_tokens'],
+                'temperature': 0.3,
+                'top_p': 0.85,
+            },
+            'cache': {
+                'enabled': SPACES_CONFIG['cache_enabled'],
+                'max_size_mb': SPACES_CONFIG['max_memory_mb'],
+                'persistent': False,
+                'ttl_hours': 1,
+            },
+            'processing': {
+                'chunk_size': 2048,  # Smaller chunks for memory
+                'chunk_overlap': 128,
+                'batch_size': 4,  # Smaller batch size
+                'clean_text': True,
+            }
+        }
+
+        # Update configuration with Spaces defaults
+        st.session_state.config_manager.update_config(spaces_defaults)
+
+    if 'performance_monitor' not in st.session_state:
+        st.session_state.performance_monitor = PerformanceMonitor(max_history=100)
+
+    if 'text_processor' not in st.session_state:
+        st.session_state.text_processor = TextProcessor()
+
+    if 'current_analysis' not in st.session_state:
+        st.session_state.current_analysis = None
+
+    if 'analysis_results' not in st.session_state:
+        st.session_state.analysis_results = []
+
+    if 'processing_status' not in st.session_state:
+        st.session_state.processing_status = {
+            'is_running': False,
+            'progress': 0,
+            'current_task': '',
+            'total_chunks': 0,
+            'processed_chunks': 0
+        }
+
+    if 'model_loaded' not in st.session_state:
+        st.session_state.model_loaded = False
+
+    if 'llm_analyzer' not in st.session_state:
+        st.session_state.llm_analyzer = None
+
+def show_spaces_optimized_home_page():
+    """Home page optimized for Spaces"""
+    st.title("🏠 NZ Legislation Loophole Analyzer")
+    st.markdown("### AI-Powered Legal Analysis (Spaces Edition)")
+
+    # Spaces-specific warnings and info
+    with st.expander("⚠️ Spaces Environment Notes", expanded=False):
+        st.info("""
+        **Running on Hugging Face Spaces**
+        - Memory optimized for cloud deployment
+        - Session-based caching (resets between visits)
+        - Use smaller models for best performance
+        - Analysis results persist during your session
+        """)
+
+    col1, col2 = st.columns([2, 1])
+
+    with col1:
+        st.markdown("""
+        This AI-powered tool analyzes New Zealand legislation to identify:
+
+        🔍 **Potential Loopholes** - Legal ambiguities that could be exploited
+        📋 **Unintended Consequences** - Hidden implications in legislative language
+        ⚖️ **Ambiguities** - Vague or unclear legal provisions
+        🎯 **Circumvention Strategies** - Ways legislation might be bypassed
+
+        **Key Features:**
+        - **Smart Caching**: Avoid re-processing identical content during your session
+        - **Memory Optimized**: Designed for Spaces memory constraints
+        - **Real-time Progress**: Live processing status and performance metrics
+        - **Export Options**: Download results in multiple formats
+        """)
+
+        st.markdown("### Quick Start")
+        st.markdown("""
+        1. **Upload** your NZ legislation files (JSON lines or raw text)
+        2. **Configure** analysis parameters (use smaller models for Spaces)
+        3. **Process** the legislation with AI-powered analysis
+        4. **Review** results with interactive visualizations
+        5. **Export** findings before your session ends
+        """)
+
+    with col2:
+        st.markdown("### Current Configuration")
+
+        config = st.session_state.config_manager.get_config()
+
+        # Model settings
+        st.subheader("🤖 Model Settings")
+        st.info(f"**Model:** {config['model']['path']}")
+        st.info(f"**Context Length:** {config['model']['context_length']}")
+        st.info(f"**Max Tokens:** {config['model']['max_tokens']}")
+
+        # Processing settings
+        st.subheader("⚙️ Processing")
+        st.info(f"**Chunk Size:** {config['processing']['chunk_size']}")
+        st.info(f"**Overlap:** {config['processing']['chunk_overlap']}")
+        st.info(f"**Batch Size:** {config['processing']['batch_size']}")
+
+        # Cache settings
+        st.subheader("🧠 Cache")
+        cache_stats = st.session_state.cache_manager.get_stats()
+        st.info(f"**Status:** {'Active' if cache_stats['enabled'] else 'Disabled'}")
+        st.info(f"**Max Memory:** {SPACES_CONFIG['max_memory_mb']}MB")
+        st.info(f"**Hit Rate:** {cache_stats['hit_rate']:.1f}%")
+
+        # Memory warning
+        perf_stats = st.session_state.performance_monitor.get_stats()
+        memory_usage = perf_stats['memory_usage_mb']
+        if memory_usage > SPACES_CONFIG['max_memory_mb'] * 0.8:
+            st.warning(f"⚠️ High Memory Usage: {memory_usage:.1f}MB")
+        else:
+            st.success(f"✅ Memory Usage: {memory_usage:.1f}MB")
+
+        if st.button("🚀 Start Analysis", type="primary", use_container_width=True):
+            st.switch_page("pages/1_upload.py")
+
+def show_spaces_optimized_upload_page():
+    """Upload page optimized for Spaces"""
+    st.title("📤 Upload & Process Legislation")
+
+    # Memory warning for Spaces
+    with st.expander("💡 Spaces Optimization Tips", expanded=False):
+        st.info("""
+        **For Best Performance on Spaces:**
+        - Use smaller models (0.8B-1.5B parameters)
+        - Process files individually for large documents
+        - Keep chunk sizes under 2048 characters
+        - Monitor memory usage in the sidebar
+        """)
+
+    # File upload section
+    st.subheader("📁 Upload Legislation Files")
+
+    col1, col2 = st.columns([1, 1])
+
+    with col1:
+        uploaded_files = st.file_uploader(
+            "Select NZ legislation files",
+            accept_multiple_files=True,
+            type=['json', 'txt', 'jsonl'],
+            help="Upload JSON lines format (.jsonl), JSON arrays (.json), or raw text (.txt) files",
+            key="spaces_file_uploader"
+        )
+
+        if uploaded_files:
+            st.success(f"📄 {len(uploaded_files)} file(s) selected")
+
+            # Show file details with size warnings
+            for file in uploaded_files:
+                with st.expander(f"📋 {file.name}"):
+                    size_mb = file.size / (1024 * 1024)
+                    if size_mb > 10:  # Warning for large files
+                        st.warning(".1f")
+                    else:
+                        st.info(".1f")
+
+                    st.write(f"**Type:** {file.type}")
+
+                    # Preview content
+                    if file.type in ['text/plain', 'application/json']:
+                        content = file.read().decode('utf-8')
+                        preview_length = min(300, len(content))
+                        st.text_area("Preview", content[:preview_length] + "..." if len(content) > preview_length else content,
+                                   height=100, disabled=True)
+                        file.seek(0)  # Reset file pointer
+
+    with col2:
+        # Processing configuration optimized for Spaces
+        st.subheader("⚙️ Processing Configuration")
+
+        config = st.session_state.config_manager.get_config()
+
+        # Model settings with Spaces warnings
+        with st.expander("🤖 Model Configuration", expanded=True):
+            st.info("💡 Use smaller models (0.8B-1.5B) for best Spaces performance")
+
+            model_path = st.text_input(
+                "Model Path",
+                value=config['model']['path'],
+                help="Path to your GGUF model file (use small models for Spaces)"
+            )
+
+            context_length = st.slider(
+                "Context Length",
+                min_value=1024,
+                max_value=8192,  # Reduced max for Spaces
+                value=min(config['model']['context_length'], 4096),
+                step=512,
+                help="Maximum context length for the model"
+            )
+
+            max_tokens = st.slider(
+                "Max Response Tokens",
+                min_value=256,
+                max_value=4096,
+                value=min(config['model']['max_tokens'], 2048),
+                step=128,
+                help="Maximum tokens in model response"
+            )
+
+        # Text processing settings
+        with st.expander("📝 Text Processing", expanded=True):
+            chunk_size = st.slider(
+                "Chunk Size",
+                min_value=512,
+                max_value=4096,  # Reduced for Spaces memory
+                value=min(config['processing']['chunk_size'], 2048),
+                step=256,
+                help="Size of text chunks for processing"
+            )
+
+            chunk_overlap = st.slider(
+                "Chunk Overlap",
+                min_value=32,
+                max_value=512,
+                value=config['processing']['chunk_overlap'],
+                step=32,
+                help="Overlap between chunks for context preservation"
+            )
+
+        # Analysis settings
+        with st.expander("🔍 Analysis Settings", expanded=True):
+            analysis_depth = st.select_slider(
+                "Analysis Depth",
+                options=["Basic", "Standard", "Detailed"],  # Removed comprehensive for memory
+                value=config['analysis']['depth'],
+                help="Level of detail in legal analysis (use Standard for Spaces)"
+            )
+
+            include_recommendations = st.checkbox(
+                "Include Recommendations",
+                value=config['analysis']['include_recommendations'],
+                help="Generate specific recommendations for addressing identified issues"
+            )
+
+    # Process button and status
+    col1, col2, col3 = st.columns([1, 1, 1])
+
+    with col1:
+        if st.button("🔄 Start Processing", type="primary", use_container_width=True):
+            if not uploaded_files:
+                st.error("Please upload at least one legislation file")
+            else:
+                start_spaces_processing(uploaded_files, {
+                    'model': {
+                        'path': model_path,
+                        'context_length': context_length,
+                        'max_tokens': max_tokens
+                    },
+                    'processing': {
+                        'chunk_size': chunk_size,
+                        'chunk_overlap': chunk_overlap
+                    },
+                    'analysis': {
+                        'depth': analysis_depth,
+                        'include_recommendations': include_recommendations
+                    }
+                })
+
+    with col2:
+        if st.button("⏹️ Stop Processing", use_container_width=True):
+            stop_processing()
+
+    with col3:
+        if st.button("📊 View Results", use_container_width=True):
+            st.switch_page("pages/2_analysis.py")
+
+def start_spaces_processing(files, config):
+    """Start processing optimized for Spaces"""
+    # Check memory before starting
+    perf_stats = st.session_state.performance_monitor.get_stats()
+    if perf_stats['memory_usage_mb'] > SPACES_CONFIG['max_memory_mb'] * 0.9:
+        st.warning("⚠️ High memory usage detected. Consider clearing cache first.")
+        if st.button("Clear Cache and Continue"):
+            st.session_state.cache_manager.clear_cache()
+            st.rerun()
+        return
+
+    st.session_state.processing_status = {
+        'is_running': True,
+        'progress': 0,
+        'current_task': 'Initializing...',
+        'total_chunks': 0,
+        'processed_chunks': 0
+    }
+
+    # Update configuration
+    st.session_state.config_manager.update_config(config)
+
+    # Add memory warning
+    st.info("💡 Processing on Spaces - this may take longer than local execution")
+
+    st.rerun()
+
+def stop_processing():
+    """Stop the current processing"""
+    st.session_state.processing_status['is_running'] = False
+    st.session_state.processing_status['current_task'] = 'Stopped by user'
+
+def show_spaces_optimized_results_page():
+    """Results page optimized for Spaces"""
+    st.title("📊 Analysis Results")
+
+    # Session warning for Spaces
+    with st.expander("💾 Session-Based Storage", expanded=False):
+        st.warning("""
+        **Important:** Results are stored in your session only.
+        - Download results before closing your browser
+        - Cache resets between visits
+        - Consider using smaller models for faster processing
+        """)
+
+    if not st.session_state.analysis_results:
+        st.info("No analysis results available. Please upload and process legislation files first.")
+        return
+
+    # Results overview
+    st.subheader("📈 Results Overview")
+
+    col1, col2, col3, col4 = st.columns(4)
+
+    total_results = len(st.session_state.analysis_results)
+    total_loopholes = sum(len(result.get('loopholes', [])) for result in st.session_state.analysis_results)
+    avg_confidence = sum(result.get('confidence', 0) for result in st.session_state.analysis_results) / max(total_results, 1)
+
+    with col1:
+        st.metric("Total Analyses", total_results)
+
+    with col2:
+        st.metric("Loopholes Found", total_loopholes)
+
+    with col3:
+        st.metric("Avg Confidence", ".2f")
+
+    with col4:
+        cache_stats = st.session_state.cache_manager.get_stats()
+        st.metric("Cache Hit Rate", ".1f")
+
+    # Results display
+    st.subheader("🔍 Detailed Results")
+
+    for i, result in enumerate(st.session_state.analysis_results):
+        with st.expander(f"📋 Analysis {i+1}: {result.get('title', 'Unknown Title')}", expanded=i==0):
+            col1, col2 = st.columns([2, 1])
+
+            with col1:
+                st.markdown("**Summary:**")
+                st.write(result.get('summary', 'No summary available'))
+
+                st.markdown("**Key Findings:**")
+                for finding in result.get('loopholes', []):
+                    st.markdown(f"- {finding}")
+
+            with col2:
+                st.metric("Confidence", ".2f")
+                st.metric("Processing Time", ".2f")
+                st.metric("Chunks Processed", result.get('chunks_processed', 0))
+
+    # Export options with Spaces warning
+    st.subheader("💾 Export Results")
+
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        if st.button("📄 Export as JSON", use_container_width=True):
+            export_results('json')
+
+    with col2:
+        if st.button("📊 Export as CSV", use_container_width=True):
+            export_results('csv')
+
+    with col3:
+        if st.button("📋 Export as Excel", use_container_width=True):
+            export_results('excel')
+
+def export_results(format_type):
+    """Export analysis results in specified format"""
+    # TODO: Implement export functionality
+    st.success(f"Results exported as {format_type.upper()} - download will be available in the next version")
+
+def show_spaces_optimized_settings_page():
+    """Settings page optimized for Spaces"""
+    st.title("⚙️ Settings & Configuration")
+
+    # Spaces-specific info
+    with st.expander("🌐 Spaces Environment", expanded=False):
+        st.info("""
+        **Spaces-Specific Settings:**
+        - Memory limit: 512MB cache (conservative)
+        - Session-based storage only
+        - No persistent data between visits
+        - Optimized for cloud performance
+        """)
+
+    tabs = st.tabs(["🤖 Model Settings", "📝 Processing", "🧠 Cache", "📊 Performance"])
+
+    with tabs[0]:
+        st.subheader("🤖 Model Configuration")
+
+        config = st.session_state.config_manager.get_config()
+
+        st.info("💡 For Spaces: Use smaller models (0.8B-1.5B parameters) for best performance")
+
+        model_path = st.text_input(
+            "Model Path",
+            value=config['model']['path'],
+            help="Path to your GGUF model file (smaller models recommended)"
+        )
+
+        context_length = st.slider(
+            "Context Length",
+            min_value=1024,
+            max_value=8192,
+            value=config['model']['context_length'],
+            step=512,
+            help="Maximum context length (smaller = faster processing)"
+        )
+
+        max_tokens = st.slider(
+            "Max Response Tokens",
+            min_value=256,
+            max_value=4096,
+            value=config['model']['max_tokens'],
+            step=128,
+            help="Maximum tokens in response (smaller = faster)"
+        )
+
+        temperature = st.slider(
+            "Temperature",
+            min_value=0.0,
+            max_value=1.0,
+            value=config['model']['temperature'],
+            step=0.1,
+            help="Controls randomness (lower = more consistent)"
+        )
+
+    with tabs[1]:
+        st.subheader("📝 Text Processing")
+
+        chunk_size = st.slider(
+            "Chunk Size",
+            min_value=512,
+            max_value=4096,
+            value=config['processing']['chunk_size'],
+            step=256,
+            help="Text chunk size (smaller = more memory efficient)"
+        )
+
+        chunk_overlap = st.slider(
+            "Chunk Overlap",
+            min_value=32,
+            max_value=512,
+            value=config['processing']['chunk_overlap'],
+            step=32,
+            help="Overlap between chunks for context"
+        )
+
+        batch_size = st.slider(
+            "Batch Size",
+            min_value=1,
+            max_value=8,  # Reduced for Spaces
+            value=config['processing']['batch_size'],
+            step=1,
+            help="Number of chunks to process at once (lower = less memory)"
+        )
+
+    with tabs[2]:
+        st.subheader("🧠 Cache Configuration")
+
+        enable_cache = st.checkbox(
+            "Enable Caching",
+            value=config['cache']['enabled'],
+            help="Use cache to avoid re-processing (recommended)"
+        )
+
+        st.info(f"💡 Max cache size: {SPACES_CONFIG['max_memory_mb']}MB (fixed for Spaces)")
+
+        cache_ttl = st.slider(
+            "Cache TTL (hours)",
+            min_value=0.5,
+            max_value=2.0,
+            value=config['cache']['ttl_hours'],
+            step=0.5,
+            help="How long to keep cached results (shorter = less memory)"
+        )
+
+    with tabs[3]:
+        st.subheader("📊 Performance Monitoring")
+
+        perf_stats = st.session_state.performance_monitor.get_stats()
+
+        col1, col2, col3 = st.columns(3)
+
+        with col1:
+            st.metric("Memory Usage", ".1f", "MB")
+
+        with col2:
+            st.metric("Cache Hit Rate", ".1f", "%")
+
+        with col3:
+            st.metric("Active Threads", perf_stats.get('active_threads', 0))
+
+        # Performance recommendations
+        recommendations = st.session_state.performance_monitor.get_recommendations()
+        if recommendations:
+            st.subheader("💡 Recommendations")
+            for rec in recommendations:
+                if "High" in rec or "Low" in rec:
+                    st.warning(rec)
+                else:
+                    st.info(rec)
+
+    # Save settings
+    col1, col2 = st.columns([1, 1])
+
+    with col1:
+        if st.button("💾 Save Settings", type="primary", use_container_width=True):
+            new_config = {
+                'model': {
+                    'path': model_path,
+                    'context_length': context_length,
+                    'max_tokens': max_tokens,
+                    'temperature': temperature
+                },
+                'processing': {
+                    'chunk_size': chunk_size,
+                    'chunk_overlap': chunk_overlap,
+                    'batch_size': batch_size
+                },
+                'cache': {
+                    'enabled': enable_cache,
+                    'ttl_hours': cache_ttl
+                }
+            }
+
+            st.session_state.config_manager.update_config(new_config)
+            st.success("Settings saved successfully!")
+
+    with col2:
+        if st.button("🔄 Reset to Defaults", use_container_width=True):
+            st.session_state.config_manager.reset_to_defaults()
+            st.success("Settings reset to defaults!")
+            st.rerun()
+
+def show_spaces_optimized_performance_page():
+    """Performance page optimized for Spaces"""
+    st.title("📈 Performance Dashboard")
+
+    # Spaces-specific info
+    with st.expander("🌐 Spaces Performance Notes", expanded=False):
+        st.info("""
+        **Spaces Environment:**
+        - Memory limit: ~2-8GB shared
+        - Cache: Session-based only
+        - Performance: Optimized for cloud
+        - Monitoring: Real-time metrics
+        """)
+
+    # Real-time metrics
+    st.subheader("📊 Real-time Metrics")
+
+    col1, col2, col3, col4 = st.columns(4)
+
+    perf_stats = st.session_state.performance_monitor.get_stats()
+
+    with col1:
+        st.metric("Memory Usage", ".1f", "MB")
+
+    with col2:
+        st.metric("Memory %", ".1f", "%")
+
+    with col3:
+        st.metric("CPU Usage", ".1f", "%")
+
+    with col4:
+        cache_stats = st.session_state.cache_manager.get_stats()
+        st.metric("Cache Hit Rate", ".1f", "%")
+
+    # Memory warning for Spaces
+    memory_percent = perf_stats.get('memory_percent', 0)
+    if memory_percent > 80:
+        st.error("⚠️ High memory usage - consider clearing cache")
+    elif memory_percent > 60:
+        st.warning("⚠️ Moderate memory usage")
+    else:
+        st.success("✅ Memory usage within limits")
+
+    # Cache performance
+    st.subheader("🧠 Cache Performance")
+
+    cache_stats = st.session_state.cache_manager.get_stats()
+
+    col1, col2, col3, col4 = st.columns(4)
+
+    with col1:
+        st.metric("Total Requests", cache_stats['hits'] + cache_stats['misses'])
+
+    with col2:
+        st.metric("Cache Hits", cache_stats['hits'])
+
+    with col3:
+        st.metric("Cache Misses", cache_stats['misses'])
+
+    with col4:
+        st.metric("Hit Rate", ".1f")
+
+    # Performance recommendations
+    st.subheader("💡 Performance Recommendations")
+
+    recommendations = st.session_state.performance_monitor.get_recommendations()
+
+    if recommendations:
+        for rec in recommendations:
+            if "High" in rec or "Low" in rec:
+                st.error(rec)
+            elif "Moderate" in rec or "Consider" in rec:
+                st.warning(rec)
+            else:
+                st.info(rec)
+    else:
+        st.success("✅ Performance is optimal!")
+
+    # Cache management
+    st.subheader("🧠 Cache Management")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        if st.button("🔄 Clear Cache", type="secondary", use_container_width=True):
+            st.session_state.cache_manager.clear_cache()
+            st.success("Cache cleared successfully!")
+            st.rerun()
+
+    with col2:
+        if st.button("📊 Reset Statistics", use_container_width=True):
+            st.session_state.performance_monitor.reset_stats()
+            st.success("Statistics reset!")
+            st.rerun()
+
+def main():
+    """Main application function for Spaces"""
+    # Initialize session state
+    initialize_spaces_session()
+
+    # Create sidebar with navigation and status
+    with st.sidebar:
+        st.title("⚖️ NZ Legislation Analyzer")
+        st.markdown("---")
+        st.markdown("**Spaces Edition**")
+        st.markdown("---")
+
+        # Navigation
+        pages = {
+            "🏠 Home": "home",
+            "📤 Upload & Process": "upload",
+            "📊 Analysis Results": "results",
+            "⚙️ Settings": "settings",
+            "📈 Performance": "performance"
+        }
+
+        selected_page = st.selectbox(
+            "Navigate to:",
+            list(pages.keys()),
+            key="nav_select"
+        )
+
+        st.markdown("---")
+
+        # Cache status
+        with st.expander("🧠 Cache Status", expanded=True):
+            cache_stats = st.session_state.cache_manager.get_stats()
+            st.metric("Cache Hits", cache_stats['hits'])
+            st.metric("Cache Misses", cache_stats['misses'])
+            st.metric("Hit Rate", ".1f")
+            st.metric("Cached Chunks", cache_stats['entries'])
+
+            if st.button("Clear Cache", type="secondary"):
+                st.session_state.cache_manager.clear_cache()
+                st.rerun()
+
+        # Performance metrics
+        with st.expander("📊 Performance", expanded=True):
+            perf_stats = st.session_state.performance_monitor.get_stats()
+            st.metric("Memory Usage", ".1f")
+            st.metric("CPU Usage", ".1f")
+
+        # Processing status
+        if st.session_state.processing_status['is_running']:
+            with st.expander("🔄 Processing Status", expanded=True):
+                st.progress(st.session_state.processing_status['progress'])
+                st.text(st.session_state.processing_status['current_task'])
+                st.text(f"Chunk {st.session_state.processing_status['processed_chunks']}/"
+                       f"{st.session_state.processing_status['total_chunks']}")
+
+    # Main content area
+    page = pages[selected_page]
+
+    if page == "home":
+        show_spaces_optimized_home_page()
+    elif page == "upload":
+        show_spaces_optimized_upload_page()
+    elif page == "results":
+        show_spaces_optimized_results_page()
+    elif page == "settings":
+        show_spaces_optimized_settings_page()
+    elif page == "performance":
+        show_spaces_optimized_performance_page()
+
+    # Footer with Spaces branding
+    st.markdown("---")
+    st.markdown(
+        """
+        <div style='text-align: center; color: #666; font-size: 12px;'>
+        NZ Legislation Loophole Analyzer v1.0.0 (Spaces Edition) |
+        Built with Streamlit & Llama.cpp | Hosted on 🤗 Hugging Face Spaces
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+
+if __name__ == "__main__":
+    main()