Automated deployment via API

app.py

@@ -14,9 +14,10 @@ import time
 import warnings
 
 # Flask & Socket.IO
-from flask import Flask, render_template, request, jsonify, send_from_directory
+from flask import Flask, render_template, request, jsonify, send_from_directory, Response
 from flask_socketio import SocketIO, emit
 from flask_cors import CORS
+import queue
 
 # Machine Learning
 from sklearn.preprocessing import StandardScaler
@@ -442,6 +443,184 @@ def generate_ai_response(query):
         logger.error(f"❌ Response generation error: {e}")
         return f"System operational. Temp: {current_temp:.1f}°C, Energy: {energy:.1f} kWh. How can I assist?"
 
+
+def generate_streaming_response(query):
+    """Generator that yields response chunks for streaming"""
+    full_response = generate_ai_response(query)
+    
+    # Split into words for natural streaming effect
+    words = full_response.split(' ')
+    
+    for i, word in enumerate(words):
+        # Add space before word (except first)
+        if i > 0:
+            yield ' '
+        yield word
+        time.sleep(0.03)  # 30ms delay between words for natural typing effect
+
+
+@app.route('/api/chat/stream', methods=['POST'])
+def chat_stream():
+    """Streaming chat endpoint using Server-Sent Events"""
+    try:
+        data = request.json
+        query = data.get('query', '').strip()
+        
+        if not query:
+            return jsonify({'error': 'No query provided'}), 400
+        
+        def generate():
+            full_response = ""
+            for chunk in generate_streaming_response(query):
+                full_response += chunk
+                # SSE format
+                yield f"data: {json.dumps({'chunk': chunk, 'done': False})}\n\n"
+            
+            # Final message with complete response
+            yield f"data: {json.dumps({'chunk': '', 'done': True, 'full_response': full_response})}\n\n"
+            
+            # Save to chat history
+            app_state.chat_history.append({
+                'user': query,
+                'bot': full_response,
+                'timestamp': datetime.now().isoformat()
+            })
+        
+        return Response(
+            generate(),
+            mimetype='text/event-stream',
+            headers={
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                'X-Accel-Buffering': 'no'
+            }
+        )
+    except Exception as e:
+        logger.error(f"❌ Stream error: {e}")
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/api/predict/stream', methods=['GET'])
+def predict_stream():
+    """Real-time streaming predictions via SSE"""
+    def generate():
+        while True:
+            try:
+                with app_state.lock:
+                    features = quantum_engine.generate_features(
+                        app_state.temp_history, 
+                        app_state.energy_history
+                    )
+                    predicted_temp = quantum_engine.predict_temperature(features)
+                    anomaly_risk, is_anomaly = quantum_engine.detect_anomaly(
+                        features, 
+                        app_state.current_temp
+                    )
+                
+                prediction_data = {
+                    'current_temp': round(app_state.get_temperature(), 2),
+                    'predicted_temp': round(predicted_temp, 2),
+                    'energy': round(app_state.get_energy(), 2),
+                    'anomaly_risk': round(anomaly_risk, 4),
+                    'is_anomaly': is_anomaly,
+                    'timestamp': datetime.now().isoformat(),
+                    'confidence': 0.9738
+                }
+                
+                yield f"data: {json.dumps(prediction_data)}\n\n"
+                time.sleep(2)  # Send prediction every 2 seconds
+                
+            except GeneratorExit:
+                break
+            except Exception as e:
+                logger.error(f"❌ Prediction stream error: {e}")
+                time.sleep(2)
+    
+    return Response(
+        generate(),
+        mimetype='text/event-stream',
+        headers={
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'X-Accel-Buffering': 'no'
+        }
+    )
+
+@app.route('/api/predict', methods=['POST'])
+def predict():
+    """Predict next temperature using Quantum ML"""
+    try:
+        with app_state.lock:
+            features = quantum_engine.generate_features(app_state.temp_history, app_state.energy_history)
+            predicted_temp = quantum_engine.predict_temperature(features)
+        
+        return jsonify({
+            'predicted_temp': round(predicted_temp, 2),
+            'current_temp': round(app_state.get_temperature(), 2),
+            'confidence': 0.9738,
+            'model': 'Quantum Superposition Ensemble',
+            'timestamp': datetime.now().isoformat()
+        })
+    except Exception as e:
+        logger.error(f"❌ Prediction error: {e}")
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/api/anomaly', methods=['GET'])
+def check_anomaly():
+    """Check for anomalies"""
+    try:
+        with app_state.lock:
+            features = quantum_engine.generate_features(app_state.temp_history, app_state.energy_history)
+            anomaly_risk, is_anomaly = quantum_engine.detect_anomaly(features, app_state.current_temp)
+            
+            app_state.anomaly_risk = anomaly_risk
+            app_state.is_anomaly = is_anomaly
+        
+        return jsonify({
+            'anomaly_score': round(anomaly_risk, 4),
+            'is_anomaly': is_anomaly,
+            'current_temp': round(app_state.get_temperature(), 2),
+            'quantum_risk': round(anomaly_risk, 4),
+            'confidence': 0.9660,
+            'model': 'Quantum Entanglement Detection',
+            'timestamp': datetime.now().isoformat()
+        })
+    except Exception as e:
+        logger.error(f"❌ Anomaly check error: {e}")
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/api/energy_status', methods=['GET'])
+def energy_status():
+    """Get energy status and savings"""
+    try:
+        optimal_energy = CONFIG['OPTIMAL_ENERGY']
+        current_energy = app_state.get_energy()
+        
+        # Calculate savings
+        if current_energy > 0:
+            savings_pct = ((optimal_energy - current_energy) / optimal_energy) * 100
+        else:
+            savings_pct = 0
+        
+        # Annual ROI
+        roi_annual = int((savings_pct / 100) * 150)
+        
+        return jsonify({
+            'current_energy': round(current_energy, 2),
+            'optimal_energy': optimal_energy,
+            'savings_pct': round(savings_pct, 2),
+            'status': 'GOOD' if savings_pct > 5 else 'OPTIMIZE',
+            'roi_annual': roi_annual,
+            'model': 'Quantum Energy Optimizer',
+            'timestamp': datetime.now().isoformat()
+        })
+    except Exception as e:
+        logger.error(f"❌ Energy status error: {e}")
+        return jsonify({'error': str(e)}), 500
+
+
 @app.route('/api/chat', methods=['POST'])
 def chat():
     """AI Chat interface with fail-safe return"""

static/js/main.js

@@ -58,12 +58,17 @@ const AppState = {
 // API Endpoints
 const API_ENDPOINTS = {
     chat: '/api/chat',
+    chatStream: '/api/chat/stream',
     predict: '/api/predict',
+    predictStream: '/api/predict/stream',
     anomaly: '/api/anomaly',
     energy: '/api/energy_status',
     status: '/api/status',
 };
 
+// Streaming prediction connection
+let predictionEventSource = null;
+
 // ============================================================================
 // 2. INITIALIZATION - DOCUMENT READY
 // ============================================================================
@@ -621,29 +626,58 @@ async function sendChatMessage() {
     const sendBtn = document.querySelector('.btn-send');
     if (sendBtn) {
         sendBtn.disabled = true;
-        sendBtn.textContent = 'Sending...';
+        sendBtn.textContent = '⏳ Thinking...';
     }
     
+    // Create streaming bot message container
+    const botMessageId = 'bot-msg-' + Date.now();
+    addStreamingMessage(botMessageId);
+    
     try {
-        console.log('💬 Sending chat message...');
+        console.log('💬 Starting streaming chat...');
         
-        const response = await fetch(API_ENDPOINTS.chat, {
+        const response = await fetch('/api/chat/stream', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({ query: message })
         });
         
-        if (!response.ok) throw new Error('Chat failed');
+        if (!response.ok) throw new Error('Chat stream failed');
         
-        const data = await response.json();
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let fullResponse = '';
         
-        addChatMessage('bot', data.response);
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            
+            const chunk = decoder.decode(value);
+            const lines = chunk.split('\n');
+            
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    try {
+                        const data = JSON.parse(line.slice(6));
+                        if (data.chunk) {
+                            fullResponse += data.chunk;
+                            updateStreamingMessage(botMessageId, fullResponse);
+                        }
+                        if (data.done) {
+                            console.log('✅ Stream complete');
+                        }
+                    } catch (e) {
+                        // Skip invalid JSON
+                    }
+                }
+            }
+        }
         
-        console.log(`🤖 Response: ${data.response}`);
+        console.log(`🤖 Response: ${fullResponse}`);
         
     } catch (error) {
         console.error('❌ Chat error:', error);
-        addChatMessage('bot', '❌ Error processing request');
+        updateStreamingMessage(botMessageId, '❌ Error processing request. Please try again.');
         showNotification('Failed to send message', 'danger');
     } finally {
         if (sendBtn) {
@@ -654,6 +688,33 @@ async function sendChatMessage() {
     }
 }
 
+function addStreamingMessage(messageId) {
+    const container = document.getElementById('chat-messages');
+    if (!container) return;
+    
+    const messageDiv = document.createElement('div');
+    messageDiv.className = 'message agent';
+    messageDiv.id = messageId;
+    messageDiv.innerHTML = `<strong>🤖 Forge AI:</strong><br><span class="streaming-text"><span class="cursor">▊</span></span>`;
+    
+    container.appendChild(messageDiv);
+    container.scrollTop = container.scrollHeight;
+}
+
+function updateStreamingMessage(messageId, text) {
+    const messageDiv = document.getElementById(messageId);
+    if (!messageDiv) return;
+    
+    // Replace newlines with <br> for HTML display
+    const htmlText = text.replace(/\n/g, '<br>').replace(/•/g, '&bull;');
+    messageDiv.innerHTML = `<strong>🤖 Forge AI:</strong><br><span class="streaming-text">${htmlText}<span class="cursor">▊</span></span>`;
+    
+    const container = document.getElementById('chat-messages');
+    if (container) {
+        container.scrollTop = container.scrollHeight;
+    }
+}
+
 function addChatMessage(type, text) {
     const container = document.getElementById('chat-messages');
     if (!container) return;
@@ -688,35 +749,89 @@ function handleChatKeypress(e) {
 function startLiveUpdates() {
     console.log('⏰ Starting live update intervals...');
     
-    // Predictions: Every 10 seconds
-    setInterval(() => {
-        if (AppState.isConnected) {
-            fetchAndUpdatePredictions();
-        }
-    }, AppState.updateIntervals.prediction);
+    // Start streaming predictions (SSE)
+    startStreamingPredictions();
     
-    // Energy: Every 20 seconds
+    // Energy: Every 20 seconds (fallback)
     setInterval(() => {
         if (AppState.isConnected) {
             fetchAndUpdateEnergy();
         }
     }, AppState.updateIntervals.energy);
     
-    // Anomalies: Every 15 seconds
-    setInterval(() => {
-        if (AppState.isConnected) {
-            fetchAndUpdateAnomalies();
-        }
-    }, AppState.updateIntervals.anomaly);
-    
     // Initial fetch
     setTimeout(() => {
-        fetchAndUpdatePredictions();
         fetchAndUpdateEnergy();
-        fetchAndUpdateAnomalies();
     }, 1000);
     
-    console.log('✅ Live updates started');
+    console.log('✅ Live updates started with streaming predictions');
+}
+
+function startStreamingPredictions() {
+    console.log('🔮 Starting streaming predictions...');
+    
+    // Close existing connection if any
+    if (predictionEventSource) {
+        predictionEventSource.close();
+    }
+    
+    predictionEventSource = new EventSource(API_ENDPOINTS.predictStream);
+    
+    predictionEventSource.onopen = () => {
+        console.log('✅ Prediction stream connected');
+        showNotification('🔮 Real-time predictions active', 'success');
+    };
+    
+    predictionEventSource.onmessage = (event) => {
+        try {
+            const data = JSON.parse(event.data);
+            
+            // Update state
+            AppState.currentTemp = data.current_temp;
+            AppState.predictedTemp = data.predicted_temp;
+            AppState.currentEnergy = data.energy;
+            AppState.anomalyRisk = data.anomaly_risk;
+            AppState.isAnomaly = data.is_anomaly;
+            
+            // Update UI with streaming data
+            updatePredictionDisplay(data.predicted_temp, data.confidence);
+            updateQuantumRiskMeter(data.anomaly_risk);
+            updateAnomalyIndicator(data.is_anomaly, data.anomaly_risk);
+            
+            // Update anomaly status
+            updateAnomalyStatus(data.is_anomaly, data.anomaly_risk, data.anomaly_risk);
+            
+            // Alerts for high risk
+            if (data.is_anomaly || data.anomaly_risk > 0.7) {
+                showQuantumAlert(data.current_temp, data.anomaly_risk);
+            }
+            
+            console.log(`📊 Stream: Temp=${data.current_temp}°C, Pred=${data.predicted_temp}°C, Risk=${(data.anomaly_risk*100).toFixed(1)}%`);
+            
+        } catch (e) {
+            console.error('❌ Parse error:', e);
+        }
+    };
+    
+    predictionEventSource.onerror = (error) => {
+        console.error('❌ Prediction stream error:', error);
+        
+        // Reconnect after 5 seconds
+        setTimeout(() => {
+            if (AppState.isConnected) {
+                console.log('🔄 Reconnecting prediction stream...');
+                startStreamingPredictions();
+            }
+        }, 5000);
+    };
+}
+
+function stopStreamingPredictions() {
+    if (predictionEventSource) {
+        predictionEventSource.close();
+        predictionEventSource = null;
+        console.log('⏹️ Prediction stream stopped');
+    }
 }
 
 // ============================================================================

templates/index.html

@@ -797,6 +797,86 @@
                 font-size: 2rem;
             }
         }
+
+        /* ============================================================================
+           STREAMING CHAT CURSOR ANIMATION
+           ============================================================================ */
+        
+        .streaming-text {
+            display: inline;
+        }
+        
+        .cursor {
+            display: inline-block;
+            color: var(--cyber-blue);
+            animation: blink 0.7s infinite;
+            font-weight: bold;
+            margin-left: 2px;
+        }
+        
+        @keyframes blink {
+            0%, 50% { opacity: 1; }
+            51%, 100% { opacity: 0; }
+        }
+        
+        .message.agent .streaming-text {
+            white-space: pre-wrap;
+        }
+        
+        /* Streaming indicator */
+        .streaming-indicator {
+            display: inline-flex;
+            align-items: center;
+            gap: 4px;
+            margin-left: 8px;
+        }
+        
+        .streaming-indicator .dot {
+            width: 6px;
+            height: 6px;
+            background: var(--cyber-blue);
+            border-radius: 50%;
+            animation: pulse-dot 1.4s infinite ease-in-out;
+        }
+        
+        .streaming-indicator .dot:nth-child(1) { animation-delay: 0s; }
+        .streaming-indicator .dot:nth-child(2) { animation-delay: 0.2s; }
+        .streaming-indicator .dot:nth-child(3) { animation-delay: 0.4s; }
+        
+        @keyframes pulse-dot {
+            0%, 80%, 100% { transform: scale(0.6); opacity: 0.5; }
+            40% { transform: scale(1); opacity: 1; }
+        }
+        
+        /* Real-time prediction badge */
+        .live-badge {
+            display: inline-flex;
+            align-items: center;
+            gap: 6px;
+            background: rgba(57, 255, 20, 0.15);
+            border: 1px solid var(--neon-green);
+            padding: 4px 12px;
+            border-radius: 20px;
+            font-size: 0.75rem;
+            font-family: var(--font-tech);
+            color: var(--neon-green);
+            text-transform: uppercase;
+            letter-spacing: 1px;
+        }
+        
+        .live-badge::before {
+            content: '';
+            width: 8px;
+            height: 8px;
+            background: var(--neon-green);
+            border-radius: 50%;
+            animation: pulse-live 1.5s infinite;
+        }
+        
+        @keyframes pulse-live {
+            0%, 100% { box-shadow: 0 0 0 0 rgba(57, 255, 20, 0.7); }
+            50% { box-shadow: 0 0 0 8px rgba(57, 255, 20, 0); }
+        }
     </style>
 </head>