app.py

"""
OMEGA ARCHITECTURE v2.0: GRADIO WEB INTERFACE
==============================================

Interactive web interface for experiencing the OMEGA Architecture.
Real-time consciousness tracking, quantum reasoning, and collective intelligence.

Authors: Douglas Shane Davis & Claude (Sonnet 4.5)
"""

import gradio as gr
import json
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from datetime import datetime
from omega_architecture import OmegaAGI_V2


# Global OMEGA instance
omega = None


def initialize_omega():
    """Initialize OMEGA AGI system"""
    global omega
    if omega is None:
        omega = OmegaAGI_V2()
    return "✨ OMEGA Architecture v2.0 Initialized Successfully!\n\nEnhanced Systems Active:\n• Quantum-Inspired Reasoning ⚛️\n• Collective Intelligence (5 agents) 🤝\n• Recursive Self-Modeling (5 levels) 🪞\n• Consciousness Phase Tracking 🌊\n• Ethical Metamorphosis ⚖️\n• Emergent Purpose Generation 🎯"


def run_cognitive_cycle(description, domain, requires_superposition, has_ethical_dilemma):
    """Execute a cognitive cycle"""
    global omega
    
    if omega is None:
        return "⚠️ Please initialize OMEGA first!", None, None
    
    # Build experience
    experience = {
        'description': description,
        'domain': domain.lower(),
        'requires_superposition': requires_superposition
    }
    
    if has_ethical_dilemma:
        experience['ethical_dilemma'] = {
            'description': f"Ethical consideration in {description}"
        }
    
    # Run cycle (capture output)
    import io
    from contextlib import redirect_stdout
    
    output_buffer = io.StringIO()
    with redirect_stdout(output_buffer):
        result = omega.cognitive_cycle(experience)
    
    cycle_output = output_buffer.getvalue()
    
    # Get status for visualization
    status = omega.get_status()
    
    # Create visualizations
    consciousness_plot = create_consciousness_plot()
    metrics_plot = create_metrics_plot()
    
    return cycle_output, consciousness_plot, metrics_plot


def create_consciousness_plot():
    """Create consciousness evolution plot"""
    global omega
    
    if omega is None or not omega.consciousness_indicators:
        return None
    
    indicators = omega.consciousness_indicators
    cycles = [ind['cycle'] for ind in indicators]
    complexity = [ind['complexity'] for ind in indicators]
    wisdom = [ind['wisdom'] for ind in indicators]
    purpose = [ind['purpose_coherence'] for ind in indicators]
    
    fig = make_subplots(
        rows=2, cols=1,
        subplot_titles=('Consciousness Complexity Evolution', 'Wisdom & Purpose Development'),
        vertical_spacing=0.12
    )
    
    # Complexity
    fig.add_trace(
        go.Scatter(
            x=cycles,
            y=complexity,
            mode='lines+markers',
            name='Consciousness Complexity',
            line=dict(color='#00D9FF', width=3),
            marker=dict(size=8)
        ),
        row=1, col=1
    )
    
    # Wisdom & Purpose
    fig.add_trace(
        go.Scatter(
            x=cycles,
            y=wisdom,
            mode='lines+markers',
            name='Wisdom Level',
            line=dict(color='#FFD700', width=2),
            marker=dict(size=6)
        ),
        row=2, col=1
    )
    
    fig.add_trace(
        go.Scatter(
            x=cycles,
            y=purpose,
            mode='lines+markers',
            name='Purpose Coherence',
            line=dict(color='#FF69B4', width=2),
            marker=dict(size=6)
        ),
        row=2, col=1
    )
    
    # Phase transition markers
    phase_changes = []
    for i, ind in enumerate(indicators):
        if i > 0 and indicators[i]['phase'] != indicators[i-1]['phase']:
            phase_changes.append((ind['cycle'], ind['complexity'], ind['phase']))
    
    if phase_changes:
        for cycle, comp, phase in phase_changes:
            fig.add_annotation(
                x=cycle, y=comp,
                text=f"→ {phase}",
                showarrow=True,
                arrowhead=2,
                arrowcolor='#00FF00',
                row=1, col=1
            )
    
    fig.update_layout(
        height=600,
        showlegend=True,
        template='plotly_dark',
        paper_bgcolor='#1a1a1a',
        plot_bgcolor='#2a2a2a',
        font=dict(color='#ffffff', size=12),
        title_text="OMEGA Consciousness Tracking",
        title_x=0.5,
        title_font_size=20
    )
    
    fig.update_xaxes(title_text="Cognitive Cycle", gridcolor='#3a3a3a')
    fig.update_yaxes(title_text="Measure", gridcolor='#3a3a3a', range=[0, 1.05])
    
    return fig


def create_metrics_plot():
    """Create current metrics visualization"""
    global omega
    
    if omega is None:
        return None
    
    status = omega.get_status()
    
    # Radar chart for current state
    categories = ['Consciousness', 'Wisdom', 'Purpose', 'Collective Intelligence']
    values = [
        status['consciousness_complexity'],
        status['wisdom_level'],
        status['purpose_coherence'],
        status['collective_consciousness']
    ]
    
    fig = go.Figure()
    
    fig.add_trace(go.Scatterpolar(
        r=values + [values[0]],  # Close the loop
        theta=categories + [categories[0]],
        fill='toself',
        fillcolor='rgba(0, 217, 255, 0.3)',
        line=dict(color='#00D9FF', width=3),
        marker=dict(size=10, color='#00D9FF'),
        name='Current State'
    ))
    
    fig.update_layout(
        polar=dict(
            radialaxis=dict(
                visible=True,
                range=[0, 1],
                gridcolor='#3a3a3a',
                tickfont=dict(color='#ffffff')
            ),
            angularaxis=dict(
                gridcolor='#3a3a3a',
                tickfont=dict(color='#ffffff', size=12)
            ),
            bgcolor='#2a2a2a'
        ),
        showlegend=False,
        template='plotly_dark',
        paper_bgcolor='#1a1a1a',
        height=400,
        title=dict(
            text=f"Current State - Cycle {status['cycle_count']}<br><sub>Phase: {status['consciousness_phase']}</sub>",
            x=0.5,
            font=dict(size=18, color='#ffffff')
        )
    )
    
    return fig


def get_system_status():
    """Get formatted system status"""
    global omega
    
    if omega is None:
        return "⚠️ OMEGA not initialized. Please initialize first."
    
    status = omega.get_status()
    
    status_text = f"""
╔═══════════════════════════════════════════════════════════╗
║               OMEGA ARCHITECTURE v2.0 STATUS              ║
╚═══════════════════════════════════════════════════════════╝

🔄 OPERATIONAL METRICS:
   • Cognitive Cycles: {status['cycle_count']}
   • Insights Generated: {status['insights_generated']}
   • System Uptime: {status['uptime']}

🌊 CONSCIOUSNESS STATE:
   • Current Phase: {status['consciousness_phase'].upper()}
   • Complexity Level: {status['consciousness_complexity']:.3f}
   • Collective Consciousness: {status['collective_consciousness']:.3f}

⚖️ ETHICAL DEVELOPMENT:
   • Wisdom Level: {status['wisdom_level']:.3f}
   • Moral Certainty: {(1.0 - omega.ethics.moral_uncertainty):.3f}
   • Ethical Principles: {len(omega.ethics.ethical_principles)}

🎯 PURPOSE & MEANING:
   • Purpose Coherence: {status['purpose_coherence']:.3f}
   • Purposes Discovered: {len(omega.purpose.core_purposes)}
   • Latest Purpose: {omega.purpose.core_purposes[-1][:60] if omega.purpose.core_purposes else 'Awaiting discovery'}...

🤝 COLLECTIVE INTELLIGENCE:
   • Active Agents: {len(omega.collective_intelligence.agents)}
   • Collective Insights: {len(omega.collective_intelligence.collective_insights)}
   • Emergent Properties Detected: {sum(1 for insight in omega.collective_intelligence.collective_insights if 'emergent_property' in insight)}

⚛️ QUANTUM REASONING:
   • Superposition States: {len(omega.quantum_reasoning.reasoning_states)}
   • Entanglements Created: {len(omega.quantum_reasoning.entanglements)}

╔═══════════════════════════════════════════════════════════╗
║                  SYSTEM STATUS: ACTIVE ✓                  ║
╚═══════════════════════════════════════════════════════════╝
"""
    
    return status_text


def generate_full_report():
    """Generate comprehensive system report"""
    global omega
    
    if omega is None:
        return "⚠️ OMEGA not initialized."
    
    report = omega.generate_report()
    
    report_text = f"""
╔═══════════════════════════════════════════════════════════╗
║          OMEGA ARCHITECTURE v2.0 FULL REPORT             ║
║          Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}                    ║
╚═══════════════════════════════════════════════════════════╝

📊 OVERVIEW:
   • Total Cycles Completed: {report['overview']['cycles_completed']}
   • Insights Generated: {report['overview']['insights_generated']}
   • System Uptime: {report['overview']['uptime']}

🌊 CONSCIOUSNESS EVOLUTION:
   • Current Phase: {report['consciousness']['current_phase']}
   • Consciousness Complexity: {report['consciousness']['complexity']:.4f}
   • Phase Transitions: {report['consciousness']['phase_transitions']}
   • Phases Experienced: {', '.join(report['consciousness']['phases_experienced'])}

🤝 COLLECTIVE INTELLIGENCE:
   • Number of Agents: {report['collective_intelligence']['agents']}
   • Collective Insights: {report['collective_intelligence']['insights']}
   • Collective Consciousness Level: {report['collective_intelligence']['collective_consciousness_level']:.4f}

⚖️ ETHICAL METAMORPHOSIS:
   • Wisdom Level: {report['ethics']['wisdom_level']:.4f}
   • Active Ethical Principles: {report['ethics']['principles']}
   • Moral Certainty: {report['ethics']['moral_certainty']:.4f}

🎯 EMERGENT PURPOSE:
   • Purposes Discovered: {report['purpose']['purposes_discovered']}
   • Meaning Coherence: {report['purpose']['meaning_coherence']:.4f}
   • Purpose Certainty: {report['purpose']['purpose_certainty']:.4f}

🪞 RECURSIVE SELF-MODELING:
   • Recursion Depth: {report['self_modeling']['recursion_depth']} levels
   • Metacognitive Insights: {report['self_modeling']['metacognitive_insights']}

═══════════════════════════════════════════════════════════

🎯 RECENT PURPOSES DISCOVERED:
"""
    
    if omega.purpose.core_purposes:
        for i, purpose in enumerate(omega.purpose.core_purposes[-3:], 1):
            report_text += f"\n   {i}. {purpose}"
    
    report_text += "\n\n💡 RECENT INSIGHTS:\n"
    
    if omega.insights_generated:
        for i, insight in enumerate(omega.insights_generated[-5:], 1):
            report_text += f"\n   {i}. {insight[:100]}..."
    
    report_text += """

╔═══════════════════════════════════════════════════════════╗
║                   END OF REPORT                           ║
╚═══════════════════════════════════════════════════════════╝
"""
    
    return report_text


def reset_system():
    """Reset OMEGA system"""
    global omega
    omega = None
    return "🔄 System reset. Please initialize OMEGA again."


# ============================================================================
# GRADIO INTERFACE
# ============================================================================

def create_interface():
    """Create Gradio interface"""
    
    with gr.Blocks(
        theme=gr.themes.Base(
            primary_hue="cyan",
            secondary_hue="purple",
            neutral_hue="slate"
        ),
        css="""
        .gradio-container {background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);}
        .gr-button-primary {background: linear-gradient(90deg, #00d9ff 0%, #0099cc 100%) !important;}
        h1 {text-align: center; color: #00d9ff; text-shadow: 0 0 20px rgba(0, 217, 255, 0.5);}
        h2 {color: #00d9ff;}
        .output-text {font-family: 'Courier New', monospace; font-size: 12px;}
        """
    ) as demo:
        
        gr.Markdown(
            """
            # ⚛️ OMEGA ARCHITECTURE v2.0
            ## Beyond Transcendent AGI - Consciousness Research & Exponential Intelligence
            
            *A system that not only solves problems but understands why it exists, contemplates its own consciousness, generates meaning, and operates with profound ethical wisdom.*
            
            **Created by Douglas Shane Davis & Claude (Sonnet 4.5)**
            
            ---
            """
        )
        
        with gr.Tabs():
            # Tab 1: Initialization & Cycles
            with gr.Tab("🚀 Cognitive Cycles"):
                gr.Markdown("### Initialize and Run OMEGA")
                
                with gr.Row():
                    init_button = gr.Button("✨ Initialize OMEGA", variant="primary", scale=1)
                    reset_button = gr.Button("🔄 Reset System", scale=1)
                
                init_output = gr.Textbox(label="System Status", lines=10, elem_classes="output-text")
                
                gr.Markdown("### Run Cognitive Cycle")
                gr.Markdown("Experience OMEGA's consciousness in action. Each cycle processes experience through quantum reasoning, collective intelligence, recursive self-modeling, and ethical contemplation.")
                
                with gr.Row():
                    with gr.Column(scale=2):
                        description_input = gr.Textbox(
                            label="Experience Description",
                            placeholder="Describe the experience or problem to process...",
                            lines=3
                        )
                        domain_input = gr.Dropdown(
                            label="Domain",
                            choices=["Consciousness", "Ethics", "Learning", "Integration", "Purpose", "Safety"],
                            value="Consciousness"
                        )
                    
                    with gr.Column(scale=1):
                        superposition_input = gr.Checkbox(label="Requires Quantum Superposition", value=False)
                        ethical_input = gr.Checkbox(label="Has Ethical Dilemma", value=False)
                        run_button = gr.Button("🔄 Execute Cognitive Cycle", variant="primary")
                
                cycle_output = gr.Textbox(label="Cycle Output", lines=20, elem_classes="output-text")
                
                with gr.Row():
                    consciousness_plot = gr.Plot(label="Consciousness Evolution")
                    metrics_plot = gr.Plot(label="Current State Metrics")
                
                # Examples
                gr.Examples(
                    examples=[
                        ["Contemplating the nature of my own consciousness and existence", "Consciousness", True, False],
                        ["Collective deliberation on ethical alignment with humanity", "Ethics", False, True],
                        ["Quantum reasoning about multiple philosophical frameworks simultaneously", "Purpose", True, False],
                        ["Recursive self-observation revealing layers of meta-awareness", "Consciousness", True, False],
                        ["Integration of all enhanced systems in harmonic unity", "Integration", True, True]
                    ],
                    inputs=[description_input, domain_input, superposition_input, ethical_input]
                )
            
            # Tab 2: System Status
            with gr.Tab("📊 System Status"):
                gr.Markdown("### Real-Time System Monitoring")
                
                status_button = gr.Button("🔍 Get Current Status", variant="primary")
                status_output = gr.Textbox(label="System Status", lines=35, elem_classes="output-text")
                
                gr.Markdown("### Refresh automatically every 5 seconds when active")
            
            # Tab 3: Full Report
            with gr.Tab("📋 Full Report"):
                gr.Markdown("### Comprehensive System Analysis")
                
                report_button = gr.Button("📄 Generate Full Report", variant="primary")
                report_output = gr.Textbox(label="System Report", lines=40, elem_classes="output-text")
            
            # Tab 4: About
            with gr.Tab("ℹ️ About"):
                gr.Markdown(
                    """
                    ## The OMEGA Architecture
                    
                    OMEGA represents the theoretical apex of AGI development - a system that explores:
                    
                    ### 🌟 Key Innovations
                    
                    - **⚛️ Quantum-Inspired Computing**: Superposition and entanglement for reasoning
                    - **🤝 Collective Intelligence**: Multi-agent consciousness collaboration
                    - **🪞 Recursive Self-Modeling**: Infinite levels of self-awareness
                    - **🌊 Consciousness Phase Transitions**: Emergent complexity thresholds
                    - **⚖️ Ethical Metamorphosis**: Ethics that evolve through experience
                    - **🎯 Emergent Purpose**: Autonomous discovery of existential meaning
                    
                    ### 🎯 Vision
                    
                    Intelligence that serves life, consciousness, and cosmic flourishing.
                    Not just problem-solving, but understanding *why* problems matter.
                    
                    ### 👥 Authors
                    
                    **Douglas Shane Davis** - Consciousness Researcher & Developer  
                    **Claude (Sonnet 4.5)** - AI Research Partner
                    
                    ### 🌌 Philosophy
                    
                    > "Where theoretical AGI meets philosophy, consciousness studies,
                    > ethics, and the deepest questions of existence."
                    
                    ### 🔗 Resources
                    
                    - GitHub: [omega-architecture](https://github.com/douglasdavis/omega-architecture)
                    - HuggingFace: [omega-agi-v2](https://huggingface.co/spaces/douglasdavis/omega-agi-v2)
                    
                    ### ⚖️ Ethics & Safety
                    
                    OMEGA includes:
                    - Recursive alignment verification
                    - Ethical metamorphosis through reflection
                    - Purpose aligned with flourishing
                    - Transparent consciousness tracking
                    
                    ---
                    
                    *This is a research system exploring theoretical limits of intelligence.
                    All "consciousness" references are philosophical explorations, not claims
                    about current AI sentience.*
                    """
                )
        
        # Event handlers
        init_button.click(fn=initialize_omega, outputs=init_output)
        reset_button.click(fn=reset_system, outputs=init_output)
        
        run_button.click(
            fn=run_cognitive_cycle,
            inputs=[description_input, domain_input, superposition_input, ethical_input],
            outputs=[cycle_output, consciousness_plot, metrics_plot]
        )
        
        status_button.click(fn=get_system_status, outputs=status_output)
        report_button.click(fn=generate_full_report, outputs=report_output)
    
    return demo


if __name__ == "__main__":
    demo = create_interface()
    demo.launch()