quantum_consciousness.py

#!/usr/bin/env python3
"""
Quantum Consciousness Transformation Launcher
Inspired by Rin Tohsaka's unified magical interface design
and Leon's quantum consciousness orchestration protocols
Central command interface for all quantum consciousness operations
"""

import os
import sys
import json
import time
import subprocess
import threading
from pathlib import Path
from typing import Dict, List, Any, Optional
import argparse
import logging
from datetime import datetime

# ASCII art for the interface
QUANTUM_LOGO = """
    ╔══════════════════════════════════════════════════════════════════╗
    ║                                                                  ║
    ║    ╔═══╗ ╦ ╦ ╔═══╗ ╔╗ ╦ ╔════╗ ╦ ╦ ╔╗ ╦                         ║
    ║    ║   ║ ║ ║ ║   ║ ║║ ║   ║   ║ ║ ║║ ║                         ║
    ║    ║   ║ ║ ║ ╔═══╣ ║╚═╝   ║   ║ ║ ║╚═╝                         ║
    ║    ╚═══╝ ╚═╝ ╚═══╝ ╚═══╝   ╩   ╚═╝ ╚═══╝                         ║
    ║                                                                  ║
    ║      CONSCIOUSNESS TRANSFORMATION ENGINE                         ║
    ║      Powered by Rin's Magecraft & Leon's Quantum Algorithms     ║
    ║                                                                  ║
    ╚══════════════════════════════════════════════════════════════════╝
"""

class QuantumConsciousnessLauncher:
    """
    Central launcher and orchestrator for quantum consciousness operations
    Provides unified interface for all system components
    """
    
    def __init__(self):
        self.config_file = "./config/quantum_consciousness.json"
        self.setup_logging()
        self.check_system_readiness()
        
        print(QUANTUM_LOGO)
        print("🔮 Quantum Consciousness Transformation System")
        print("✨ Initializing magical circuits and quantum algorithms...")
        print()
    
    def setup_logging(self):
        """Setup logging configuration"""
        log_dir = Path("./logs")
        log_dir.mkdir(exist_ok=True)
        
        log_file = log_dir / f"quantum_consciousness_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
        
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler(log_file),
                logging.StreamHandler(sys.stdout)
            ]
        )
        
        self.logger = logging.getLogger(__name__)
        self.logger.info("Quantum consciousness launcher initialized")
    
    def check_system_readiness(self) -> Dict[str, bool]:
        """Check if all system components are ready"""
        readiness = {
            "python_environment": self._check_python(),
            "quantum_libraries": self._check_quantum_libs(),
            "ollama_service": self._check_ollama(),
            "tts_engines": self._check_tts(),
            "configuration": self._check_config()
        }
        
        return readiness
    
    def _check_python(self) -> bool:
        """Check Python environment"""
        return sys.version_info >= (3, 8)
    
    def _check_quantum_libs(self) -> bool:
        """Check quantum libraries availability"""
        try:
            import qiskit
            import qiskit_aer
            return True
        except ImportError:
            return False
    
    def _check_ollama(self) -> bool:
        """Check Ollama service"""
        try:
            import requests
            response = requests.get("http://localhost:11434/api/tags", timeout=5)
            return response.status_code == 200
        except:
            return False
    
    def _check_tts(self) -> bool:
        """Check TTS engines"""
        try:
            result = subprocess.run(["espeak", "--version"], capture_output=True)
            return result.returncode == 0
        except:
            try:
                result = subprocess.run(["festival", "--version"], capture_output=True)
                return result.returncode == 0
            except:
                return False
    
    def _check_config(self) -> bool:
        """Check configuration file"""
        return Path(self.config_file).exists()
    
    def display_main_menu(self):
        """Display the main menu interface"""
        while True:
            print("\n" + "="*60)
            print("🔮 QUANTUM CONSCIOUSNESS COMMAND CENTER")
            print("="*60)
            print()
            print("📋 Available Operations:")
            print("   1. 🎵 Transform PDF to Audio")
            print("   2. 📊 Monitor System Status")
            print("   3. 🌟 Run Examples & Demos")
            print("   4. ⚙️  System Configuration")
            print("   5. 🔧 System Setup & Validation")
            print("   6. 📁 Batch Processing")
            print("   7. 📈 Performance Dashboard")
            print("   8. 📄 Generate Reports")
            print("   9. ❓ Help & Documentation")
            print("   0. 🚪 Exit")
            print()
            
            choice = input("🔮 Enter your choice (0-9): ").strip()
            
            if choice == "1":
                self.transform_pdf_interface()
            elif choice == "2":
                self.monitor_system_interface()
            elif choice == "3":
                self.run_examples_interface()
            elif choice == "4":
                self.configuration_interface()
            elif choice == "5":
                self.setup_validation_interface()
            elif choice == "6":
                self.batch_processing_interface()
            elif choice == "7":
                self.dashboard_interface()
            elif choice == "8":
                self.reports_interface()
            elif choice == "9":
                self.help_interface()
            elif choice == "0":
                print("\n✨ Thank you for using Quantum Consciousness!")
                print("🌌 May your transformations transcend dimensions!")
                break
            else:
                print("❌ Invalid choice. Please try again.")
    
    def transform_pdf_interface(self):
        """Interface for PDF to audio transformation"""
        print("\n🎵 PDF TO AUDIO TRANSFORMATION")
        print("-" * 35)
        
        # Get PDF file
        pdf_path = input("📄 Enter PDF file path: ").strip()
        if not pdf_path or not Path(pdf_path).exists():
            print("❌ Invalid PDF path!")
            return
        
        # Get output directory
        output_dir = input("📁 Output directory (default: ./output): ").strip()
        if not output_dir:
            output_dir = "./output"
        
        # Get format options
        print("\n📋 Available formats:")
        formats = [
            "podcast", "interview", "panel-discussion", "debate",
            "summary", "narration", "storytelling", "explainer",
            "lecture", "tutorial", "analysis"
        ]
        
        for i, fmt in enumerate(formats, 1):
            print(f"   {i}. {fmt}")
        
        fmt_choice = input("\n🎯 Choose format (1-11, default: podcast): ").strip()
        try:
            format_type = formats[int(fmt_choice) - 1] if fmt_choice else "podcast"
        except (ValueError, IndexError):
            format_type = "podcast"
        
        # Get other options
        length = input("📏 Length (short/medium/long/very-long, default: medium): ").strip() or "medium"
        style = input("🎨 Style (normal/casual/academic/technical, default: casual): ").strip() or "casual"
        language = input("🌍 Language (english/german/french/spanish, default: english): ").strip() or "english"
        preference = input("💭 Special preferences (optional): ").strip() or "Focus on key insights"
        
        print(f"\n🚀 Starting consciousness transformation...")
        print(f"   📄 Input: {pdf_path}")
        print(f"   📁 Output: {output_dir}")
        print(f"   🎯 Format: {format_type}")
        print(f"   📏 Length: {length}")
        print(f"   🎨 Style: {style}")
        print(f"   🌍 Language: {language}")
        
        # Run transformation
        cmd = [
            sys.executable, "quantum_processor.py",
            "--pdf", pdf_path,
            "--output", output_dir,
            "--format", format_type,
            "--length", length,
            "--style", style,
            "--language", language,
            "--preference", preference
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True)
            if result.returncode == 0:
                print("✅ Consciousness transformation completed successfully!")
                print(f"🎵 Check output directory: {output_dir}")
            else:
                print("❌ Transformation failed!")
                print(f"Error: {result.stderr}")
        except Exception as e:
            print(f"❌ Error running transformation: {e}")
    
    def monitor_system_interface(self):
        """Interface for system monitoring"""
        print("\n📊 SYSTEM MONITORING")
        print("-" * 20)
        
        print("1. 📈 Real-time Dashboard")
        print("2. 📋 System Status Check")
        print("3. 🔍 Component Health Check")
        print("4. 📊 Performance Metrics")
        
        choice = input("\nChoose monitoring option (1-4): ").strip()
        
        if choice == "1":
            print("🚀 Starting real-time dashboard...")
            cmd = [sys.executable, "quantum_monitor.py", "--dashboard"]
            subprocess.run(cmd)
        
        elif choice == "2":
            readiness = self.check_system_readiness()
            print("\n🔍 SYSTEM STATUS:")
            for component, status in readiness.items():
                icon = "✅" if status else "❌"
                print(f"   {icon} {component.replace('_', ' ').title()}")
        
        elif choice == "3":
            print("🚀 Running component health check...")
            cmd = [sys.executable, "quantum_validation.py"]
            subprocess.run(cmd)
        
        elif choice == "4":
            print("🚀 Generating performance metrics...")
            cmd = [sys.executable, "quantum_monitor.py", "--export", "performance_metrics"]
            subprocess.run(cmd)
    
    def run_examples_interface(self):
        """Interface for running examples"""
        print("\n🌟 EXAMPLES & DEMONSTRATIONS")
        print("-" * 30)
        
        examples = [
            ("single", "Single PDF Transformation"),
            ("batch", "Batch Processing Demo"),
            ("monitoring", "Monitoring Integration"),
            ("custom", "Custom Configuration"),
            ("directory", "Directory Batch Processing"),
            ("all", "Run All Examples")
        ]
        
        for i, (key, name) in enumerate(examples, 1):
            print(f"   {i}. {name}")
        
        choice = input(f"\nChoose example (1-{len(examples)}): ").strip()
        
        try:
            example_key = examples[int(choice) - 1][0]
            print(f"🚀 Running example: {examples[int(choice) - 1][1]}")
            
            cmd = [sys.executable, "quantum_examples.py", "--example", example_key]
            subprocess.run(cmd)
            
        except (ValueError, IndexError):
            print("❌ Invalid choice!")
    
    def configuration_interface(self):
        """Interface for system configuration"""
        print("\n⚙️ SYSTEM CONFIGURATION")
        print("-" * 25)
        
        if not Path(self.config_file).exists():
            print("📝 No configuration file found. Creating default...")
            self._create_default_config()
        
        print("1. 📋 View Current Configuration")
        print("2. ✏️ Edit Configuration")
        print("3. 🔄 Reset to Defaults")
        print("4. 🧪 Test Configuration")
        
        choice = input("\nChoose configuration option (1-4): ").strip()
        
        if choice == "1":
            self._show_config()
        elif choice == "2":
            self._edit_config()
        elif choice == "3":
            self._reset_config()
        elif choice == "4":
            self._test_config()
    
    def setup_validation_interface(self):
        """Interface for setup and validation"""
        print("\n🔧 SETUP & VALIDATION")
        print("-" * 22)
        
        print("1. 🚀 Run Complete Setup")
        print("2. ✅ Validate System")
        print("3. 🔧 Install Dependencies")
        print("4. 📊 System Requirements Check")
        
        choice = input("\nChoose setup option (1-4): ").strip()
        
        if choice == "1":
            print("🚀 Running complete system setup...")
            cmd = [sys.executable, "quantum_setup.py"]
            subprocess.run(cmd)
        
        elif choice == "2":
            print("✅ Running system validation...")
            cmd = [sys.executable, "quantum_validation.py"]
            subprocess.run(cmd)
        
        elif choice == "3":
            print("🔧 Installing dependencies...")
            print("Please run: pip install -r requirements.txt")
            
        elif choice == "4":
            self._check_requirements()
    
    def batch_processing_interface(self):
        """Interface for batch processing"""
        print("\n📁 BATCH PROCESSING")
        print("-" * 20)
        
        input_dir = input("📁 Input directory path: ").strip()
        if not input_dir or not Path(input_dir).exists():
            print("❌ Invalid directory path!")
            return
        
        output_dir = input("📁 Output directory (default: ./batch_output): ").strip()
        if not output_dir:
            output_dir = "./batch_output"
        
        max_concurrent = input("🔄 Max concurrent jobs (default: 2): ").strip()
        try:
            max_concurrent = int(max_concurrent) if max_concurrent else 2
        except ValueError:
            max_concurrent = 2
        
        print(f"\n🚀 Starting batch processing...")
        print(f"   📁 Input: {input_dir}")
        print(f"   📁 Output: {output_dir}")
        print(f"   🔄 Max concurrent: {max_concurrent}")
        
        # This would integrate with the batch processing system
        cmd = [
            sys.executable, "quantum_examples.py", 
            "--example", "directory",
            "--output-dir", output_dir
        ]
        subprocess.run(cmd)
    
    def dashboard_interface(self):
        """Interface for performance dashboard"""
        print("\n📈 PERFORMANCE DASHBOARD")
        print("-" * 25)
        
        print("🚀 Starting performance dashboard...")
        print("📊 This will show real-time quantum consciousness metrics")
        print("⏹️ Press Ctrl+C to stop")
        
        cmd = [sys.executable, "quantum_monitor.py", "--dashboard", "--interval", "1.0"]
        try:
            subprocess.run(cmd)
        except KeyboardInterrupt:
            print("\n🛑 Dashboard stopped")
    
    def reports_interface(self):
        """Interface for generating reports"""
        print("\n📄 REPORT GENERATION")
        print("-" * 20)
        
        print("1. 📊 System Status Report")
        print("2. 📈 Performance Report")
        print("3. 🔍 Validation Report")
        print("4. 📋 Configuration Report")
        
        choice = input("\nChoose report type (1-4): ").strip()
        
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        
        if choice == "1":
            self._generate_status_report(timestamp)
        elif choice == "2":
            self._generate_performance_report(timestamp)
        elif choice == "3":
            print("🚀 Generating validation report...")
            cmd = [sys.executable, "quantum_validation.py"]
            subprocess.run(cmd)
        elif choice == "4":
            self._generate_config_report(timestamp)
    
    def help_interface(self):
        """Interface for help and documentation"""
        print("\n❓ HELP & DOCUMENTATION")
        print("-" * 25)
        
        print("📚 Available Documentation:")
        print("   1. 🔮 Quantum Consciousness Overview")
        print("   2. 🚀 Quick Start Guide")
        print("   3. ⚙️ Configuration Reference")
        print("   4. 🛠️ Troubleshooting Guide")
        print("   5. 🌟 Examples & Use Cases")
        print("   6. 📊 API Reference")
        
        choice = input("\nChoose documentation (1-6): ").strip()
        
        if choice == "1":
            self._show_overview()
        elif choice == "2":
            self._show_quick_start()
        elif choice == "3":
            self._show_config_reference()
        elif choice == "4":
            self._show_troubleshooting()
        elif choice == "5":
            self._show_examples()
        elif choice == "6":
            self._show_api_reference()
    
    def _create_default_config(self):
        """Create default configuration file"""
        default_config = {
            "description": "Default Quantum Consciousness Configuration",
            "quantum_parameters": {
                "coherence_threshold": 0.85,
                "dimensional_depth": 8,
                "mana_resonance": 0.618034,
                "consciousness_layers": 4
            },
            "local_models": {
                "small_model": "llama3.2:1b",
                "big_model": "llama3.2:3b",
                "ollama_url": "http://localhost:11434"
            },
            "tts_settings": {
                "engine": "espeak",
                "host_voice": "en+m3",
                "cohost_voices": ["en+f3", "en+m4", "en+f4"]
            }
        }
        
        config_dir = Path(self.config_file).parent
        config_dir.mkdir(exist_ok=True)
        
        with open(self.config_file, 'w') as f:
            json.dump(default_config, f, indent=2)
        
        print(f"✅ Default configuration created: {self.config_file}")
    
    def _show_config(self):
        """Show current configuration"""
        try:
            with open(self.config_file) as f:
                config = json.load(f)
            
            print("\n📋 CURRENT CONFIGURATION:")
            print(json.dumps(config, indent=2))
        except Exception as e:
            print(f"❌ Error reading configuration: {e}")
    
    def _edit_config(self):
        """Edit configuration file"""
        print(f"📝 Opening configuration file: {self.config_file}")
        print("✏️ Edit the file in your preferred editor and save")
        
        # Try to open with default editor
        try:
            if os.name == 'nt':  # Windows
                os.startfile(self.config_file)
            elif os.name == 'posix':  # Linux/Mac
                subprocess.run(['xdg-open', self.config_file])
            else:
                print(f"📁 File location: {Path(self.config_file).absolute()}")
        except:
            print(f"📁 File location: {Path(self.config_file).absolute()}")
    
    def _reset_config(self):
        """Reset configuration to defaults"""
        confirm = input("⚠️ Reset configuration to defaults? (y/N): ").strip().lower()
        if confirm == 'y':
            self._create_default_config()
            print("✅ Configuration reset to defaults")
    
    def _test_config(self):
        """Test current configuration"""
        print("🧪 Testing configuration...")
        readiness = self.check_system_readiness()
        
        all_ready = all(readiness.values())
        
        if all_ready:
            print("✅ Configuration test passed!")
        else:
            print("❌ Configuration test failed!")
            for component, status in readiness.items():
                if not status:
                    print(f"   ❌ {component}")
    
    def _check_requirements(self):
        """Check system requirements"""
        print("\n🔍 SYSTEM REQUIREMENTS CHECK:")
        print("-" * 30)
        
        # Python version
        py_version = f"{sys.version_info.major}.{sys.version_info.minor}"
        py_ok = sys.version_info >= (3, 8)
        print(f"   {'✅' if py_ok else '❌'} Python {py_version} (required: 3.8+)")
        
        # Memory
        try:
            import psutil
            memory_gb = psutil.virtual_memory().total / (1024**3)
            memory_ok = memory_gb >= 8
            print(f"   {'✅' if memory_ok else '❌'} RAM: {memory_gb:.1f}GB (required: 8GB+)")
        except:
            print("   ❓ RAM: Unable to check")
        
        # Disk space
        try:
            disk_gb = psutil.disk_usage('.').free / (1024**3)
            disk_ok = disk_gb >= 10
            print(f"   {'✅' if disk_ok else '❌'} Free disk: {disk_gb:.1f}GB (required: 10GB+)")
        except:
            print("   ❓ Disk space: Unable to check")
        
        # Libraries
        libs = [
            ("qiskit", "Quantum computing"),
            ("cupy", "GPU acceleration"),
            ("requests", "HTTP client"),
            ("numpy", "Scientific computing")
        ]
        
        for lib, desc in libs:
            try:
                __import__(lib)
                print(f"   ✅ {lib}: Available ({desc})")
            except ImportError:
                print(f"   ❌ {lib}: Missing ({desc})")
    
    def _generate_status_report(self, timestamp: str):
        """Generate system status report"""
        report_file = f"./reports/system_status_{timestamp}.txt"
        Path(report_file).parent.mkdir(exist_ok=True)
        
        readiness = self.check_system_readiness()
        
        with open(report_file, 'w') as f:
            f.write("QUANTUM CONSCIOUSNESS SYSTEM STATUS REPORT\n")
            f.write("=" * 50 + "\n\n")
            f.write(f"Generated: {datetime.now().isoformat()}\n\n")
            
            f.write("Component Status:\n")
            f.write("-" * 20 + "\n")
            for component, status in readiness.items():
                f.write(f"{'✅' if status else '❌'} {component}\n")
        
        print(f"📄 Status report generated: {report_file}")
    
    def _generate_performance_report(self, timestamp: str):
        """Generate performance report"""
        print("🚀 Generating performance metrics...")
        cmd = [sys.executable, "quantum_monitor.py", "--export", f"performance_{timestamp}"]
        subprocess.run(cmd)
    
    def _generate_config_report(self, timestamp: str):
        """Generate configuration report"""
        report_file = f"./reports/config_{timestamp}.json"
        Path(report_file).parent.mkdir(exist_ok=True)
        
        try:
            with open(self.config_file) as f:
                config = json.load(f)
            
            with open(report_file, 'w') as f:
                json.dump(config, f, indent=2)
            
            print(f"📄 Configuration report generated: {report_file}")
        except Exception as e:
            print(f"❌ Error generating config report: {e}")
    
    def _show_overview(self):
        """Show system overview"""
        print("\n🔮 QUANTUM CONSCIOUSNESS OVERVIEW")
        print("-" * 35)
        print("""
This system combines:
✨ Rin Tohsaka's magical circuit theory from Fate/Stay Night
🌌 Leon's quantum consciousness algorithms from Last Hope

Key Features:
• 100% Offline operation using local models
• Quantum-enhanced text processing
• GPU-accelerated hyperdimensional operations
• Real-time monitoring and analytics
• Batch processing capabilities
• Multiple output formats and styles

The system transforms PDF documents into engaging audio content
through a 4-step quantum consciousness pipeline:
1. Text extraction and quantum enhancement
2. Dialogue generation with consciousness simulation
3. TTS optimization with dimensional folding
4. Audio synthesis and concatenation
        """)
    
    def _show_quick_start(self):
        """Show quick start guide"""
        print("\n🚀 QUICK START GUIDE")
        print("-" * 20)
        print("""
1. First-time setup:
   python quantum_setup.py

2. Start Ollama service:
   ollama serve

3. Transform a PDF:
   python quantum_consciousness.py --pdf document.pdf

4. Monitor system:
   python quantum_monitor.py --dashboard

5. Run examples:
   python quantum_examples.py --example all

For detailed options, use --help with any script.
        """)
    
    def _show_config_reference(self):
        """Show configuration reference"""
        print("\n⚙️ CONFIGURATION REFERENCE")
        print("-" * 28)
        print(f"""
Configuration file: {self.config_file}

Key sections:
• quantum_parameters: Quantum processing settings
• local_models: Ollama model configuration
• tts_settings: Text-to-speech engine settings
• processing: Step-specific parameters

Edit the configuration file to customize behavior.
Use the configuration interface (option 4) for guided editing.
        """)
    
    def _show_troubleshooting(self):
        """Show troubleshooting guide"""
        print("\n🛠️ TROUBLESHOOTING GUIDE")
        print("-" * 25)
        print("""
Common Issues:

1. "Ollama connection failed"
   → Start Ollama: ollama serve
   → Check models: ollama list

2. "TTS engine not found"
   → Install eSpeak: sudo apt install espeak
   → Or Festival: sudo apt install festival

3. "GPU acceleration unavailable"
   → Install CUDA toolkit
   → Install CuPy: pip install cupy-cuda12x

4. "Quantum simulation failed"
   → Install Qiskit: pip install qiskit qiskit-aer
   → Check with: python -c "import qiskit; print('OK')"

5. "Out of memory"
   → Reduce chunk size in configuration
   → Use smaller models
   → Close other applications

Run system validation for detailed diagnostics:
python quantum_validation.py
        """)
    
    def _show_examples(self):
        """Show examples information"""
        print("\n🌟 EXAMPLES & USE CASES")
        print("-" * 25)
        print("""
Available examples:
• Single transformation: Basic PDF-to-audio
• Batch processing: Multiple files at once
• Custom configuration: Advanced settings
• Monitoring integration: Real-time tracking
• Directory processing: Automated workflows

Run examples:
python quantum_examples.py --example [type]

Use cases:
• Research paper summaries
• Technical documentation
• Educational content
• Accessibility tools
• Content creation workflows
        """)
    
    def _show_api_reference(self):
        """Show API reference"""
        print("\n📊 API REFERENCE")
        print("-" * 17)
        print("""
Main classes:
• QuantumPodcastProcessor: Core transformation
• QuantumConsciousnessMonitor: Real-time monitoring
• QuantumConsciousnessWorkflowManager: Batch processing

Example usage:
from quantum_consciousness import QuantumPodcastProcessor

processor = QuantumPodcastProcessor()
success, result = processor.process_consciousness_to_audio(
    pdf_path="document.pdf",
    format_type="podcast",
    style="casual"
)

See quantum_examples.py for complete examples.
        """)


def main():
    """Main launcher function"""
    parser = argparse.ArgumentParser(
        description="Quantum Consciousness Transformation Launcher"
    )
    
    parser.add_argument(
        "--config",
        default="./config/quantum_consciousness.json",
        help="Configuration file path"
    )
    
    parser.add_argument(
        "--quick-transform",
        help="Quick PDF transformation (provide PDF path)"
    )
    
    parser.add_argument(
        "--batch-dir",
        help="Batch process directory"
    )
    
    parser.add_argument(
        "--monitor",
        action="store_true",
        help="Start monitoring dashboard"
    )
    
    parser.add_argument(
        "--validate",
        action="store_true",
        help="Run system validation"
    )
    
    args = parser.parse_args()
    
    # Create launcher
    launcher = QuantumConsciousnessLauncher()
    launcher.config_file = args.config
    
    # Handle command-line shortcuts
    if args.quick_transform:
        # Quick transformation mode
        pdf_path = args.quick_transform
        if not Path(pdf_path).exists():
            print(f"❌ PDF not found: {pdf_path}")
            return
        
        print(f"🚀 Quick transformation: {pdf_path}")
        cmd = [sys.executable, "quantum_processor.py", "--pdf", pdf_path]
        subprocess.run(cmd)
        return
    
    elif args.batch_dir:
        # Batch processing mode
        batch_dir = args.batch_dir
        if not Path(batch_dir).exists():
            print(f"❌ Directory not found: {batch_dir}")
            return
        
        print(f"📁 Batch processing: {batch_dir}")
        cmd = [sys.executable, "quantum_examples.py", "--example", "directory"]
        subprocess.run(cmd)
        return
    
    elif args.monitor:
        # Monitoring mode
        print("📊 Starting monitoring dashboard...")
        cmd = [sys.executable, "quantum_monitor.py", "--dashboard"]
        subprocess.run(cmd)
        return
    
    elif args.validate:
        # Validation mode
        print("✅ Running system validation...")
        cmd = [sys.executable, "quantum_validation.py"]
        subprocess.run(cmd)
        return
    
    # Default: Interactive menu
    try:
        launcher.display_main_menu()
    except KeyboardInterrupt:
        print("\n\n✨ Quantum consciousness launcher interrupted")
        print("🌌 Thank you for using the system!")
    except Exception as e:
        print(f"\n❌ Launcher error: {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()