Create app.py

app.py

@@ -0,0 +1,557 @@
+#!/usr/bin/env python3
+"""
+🚗 JAY'S MOBILE WASH - IPHONE FORWARDING AI SYSTEM
+Lightweight version optimized for HuggingFace Spaces deployment
+"""
+
+import os
+import json
+import requests
+import logging
+from datetime import datetime, timedelta
+from flask import Flask, render_template, request, jsonify
+from flask_cors import CORS
+from flask_socketio import SocketIO, emit
+import threading
+from threading import Lock
+from collections import defaultdict
+import time
+import uuid
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+# Initialize Flask app
+app = Flask(__name__)
+app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', 'jays-mobile-wash-2025')
+
+# Enable CORS and SocketIO
+CORS(app)
+socketio = SocketIO(app, cors_allowed_origins="*")
+
+# Configuration
+SIGNALWIRE_PROJECT_ID = os.environ.get('SIGNALWIRE_PROJECT_ID', '')
+SIGNALWIRE_AUTH_TOKEN = os.environ.get('SIGNALWIRE_AUTH_TOKEN', '')
+SIGNALWIRE_SPACE_URL = os.environ.get('SIGNALWIRE_SPACE_URL', '')
+DEEPSEEK_API_KEY = os.environ.get('DEEPSEEK_API_KEY', '')
+
+# Business settings
+BUSINESS_NAME = "Jay's Mobile Wash"
+JAY_PHONE = os.environ.get('JAY_PHONE', '+15622289429')
+SIGNALWIRE_PHONE = os.environ.get('SIGNALWIRE_PHONE', '+17149278841')
+FORWARDING_ENABLED = True
+FORWARDING_DELAY = 20
+
+# Services and pricing
+SERVICES = {
+    'basic_wash': {'price': 25.00, 'name': 'Basic Wash'},
+    'premium_wash': {'price': 45.00, 'name': 'Premium Wash'},
+    'full_detail': {'price': 85.00, 'name': 'Full Detail'},
+    'ceramic_coating': {'price': 150.00, 'name': 'Ceramic Coating'},
+    'headlight_restoration': {'price': 35.00, 'name': 'Headlight Restoration'}
+}
+
+# Initialize SignalWire
+signalwire_client = None
+VoiceResponse = None
+MessagingResponse = None
+
+try:
+    from signalwire.rest import Client
+    from signalwire.voice_response import VoiceResponse
+    from signalwire.messaging_response import MessagingResponse
+    
+    if SIGNALWIRE_PROJECT_ID and SIGNALWIRE_AUTH_TOKEN and SIGNALWIRE_SPACE_URL:
+        signalwire_client = Client(
+            SIGNALWIRE_PROJECT_ID,
+            SIGNALWIRE_AUTH_TOKEN,
+            signalwire_space_url=SIGNALWIRE_SPACE_URL
+        )
+        print("✅ SignalWire initialized")
+    else:
+        print("⚠️ SignalWire credentials not found")
+except ImportError:
+    print("⚠️ SignalWire library not available")
+
+# Logging setup
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Thread-safe system state
+class SystemState:
+    def __init__(self):
+        self._lock = Lock()
+        self._data = {
+            'calls_today': 0,
+            'sms_today': 0,
+            'calls_forwarded': 0,
+            'ai_responses': 0,
+            'revenue_today': 0.0,
+            'active_calls': {},
+            'active_sms': {},
+            'start_time': datetime.now(),
+            'status': 'healthy'
+        }
+    
+    def get(self, key):
+        with self._lock:
+            return self._data.get(key, 0)
+    
+    def set(self, key, value):
+        with self._lock:
+            self._data[key] = value
+    
+    def increment(self, key):
+        with self._lock:
+            self._data[key] = self._data.get(key, 0) + 1
+    
+    def get_all(self):
+        with self._lock:
+            return self._data.copy()
+
+# Initialize system state
+system_state = SystemState()
+
+# Simple AI processor
+class SimpleAI:
+    def __init__(self):
+        self.response_cache = {}
+        
+    def analyze_sentiment(self, text):
+        """Simple sentiment analysis"""
+        try:
+            from textblob import TextBlob
+            blob = TextBlob(text)
+            polarity = blob.sentiment.polarity
+            return {
+                'score': polarity,
+                'label': 'positive' if polarity > 0.1 else 'negative' if polarity < -0.1 else 'neutral'
+            }
+        except:
+            return {'score': 0.0, 'label': 'neutral'}
+    
+    def detect_intent(self, text):
+        """Detect customer intent"""
+        text_lower = text.lower()
+        
+        if any(word in text_lower for word in ['price', 'cost', 'how much', 'pricing']):
+            return 'pricing'
+        elif any(word in text_lower for word in ['book', 'schedule', 'appointment', 'when']):
+            return 'booking'
+        elif any(word in text_lower for word in ['service', 'wash', 'detail', 'clean']):
+            return 'services'
+        elif any(word in text_lower for word in ['location', 'where', 'area', 'address']):
+            return 'location'
+        elif any(word in text_lower for word in ['urgent', 'emergency', 'asap', 'now']):
+            return 'urgent'
+        elif any(word in text_lower for word in ['jay', 'owner', 'human', 'person']):
+            return 'human_request'
+        else:
+            return 'general'
+    
+    def generate_response(self, user_input, context=None):
+        """Generate AI response"""
+        
+        # Check cache first
+        cache_key = f"{user_input[:50]}_{context.get('forwarded', False) if context else False}"
+        if cache_key in self.response_cache:
+            return self.response_cache[cache_key]
+        
+        intent = self.detect_intent(user_input)
+        sentiment = self.analyze_sentiment(user_input)
+        
+        # Add forwarding acknowledgment if needed
+        forwarding_ack = ""
+        if context and context.get('forwarded'):
+            forwarding_ack = "Thank you for your patience while the call was connected. "
+        
+        # Generate response based on intent
+        if intent == 'pricing':
+            response = f"{forwarding_ack}I'd be happy to help with pricing! Our basic wash is $25, premium wash is $45, and full detail is $85. Which service interests you most?"
+        
+        elif intent == 'booking':
+            response = f"{forwarding_ack}I can help you schedule an appointment! We're available Monday-Saturday 8AM-6PM, Sunday 10AM-4PM. What day works best for you?"
+        
+        elif intent == 'services':
+            response = f"{forwarding_ack}We offer mobile car detailing services: Basic wash ($25), Premium wash with wax ($45), Full detail ($85), and ceramic coating ($150). Which would you like to know more about?"
+        
+        elif intent == 'location':
+            response = f"{forwarding_ack}We provide mobile service within a 15-mile radius of Los Angeles. We come to your location! Where are you located?"
+        
+        elif intent == 'urgent':
+            response = f"{forwarding_ack}I understand this is urgent. Let me connect you with Jay directly right away for immediate assistance."
+        
+        elif intent == 'human_request':
+            response = f"{forwarding_ack}Let me connect you with Jay personally. He'll be right with you!"
+        
+        else:
+            response = f"{forwarding_ack}Hi! Thanks for contacting Jay's Mobile Wash! I can help with pricing, scheduling, or questions about our mobile car detailing services. How can I assist you today?"
+        
+        # Try DeepSeek if available for better responses
+        if DEEPSEEK_API_KEY and intent not in ['urgent', 'human_request']:
+            try:
+                deepseek_response = self.get_deepseek_response(user_input, context)
+                if deepseek_response:
+                    response = deepseek_response
+            except Exception as e:
+                logger.warning(f"DeepSeek failed: {e}")
+        
+        # Cache and return
+        self.response_cache[cache_key] = response
+        return response
+    
+    def get_deepseek_response(self, prompt, context=None):
+        """Get response from DeepSeek API"""
+        try:
+            headers = {
+                "Authorization": f"Bearer {DEEPSEEK_API_KEY}",
+                "Content-Type": "application/json"
+            }
+            
+            system_prompt = f"""You are Jay's Mobile Wash AI assistant. Be friendly and professional.
+
+BUSINESS INFO:
+- Services: Basic wash ($25), Premium wash ($45), Full detail ($85), Ceramic coating ($150), Headlight restoration ($35)
+- Hours: Mon-Sat 8AM-6PM, Sun 10AM-4PM  
+- Service area: 15 mile radius from Los Angeles
+- Owner: Jay, Phone: {JAY_PHONE}
+
+{"IMPORTANT: Customer's call was forwarded from Jay's phone. Be empathetic about any wait time." if context and context.get('forwarded') else ""}"""
+            
+            data = {
+                "model": "deepseek-chat",
+                "messages": [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": prompt}
+                ],
+                "max_tokens": 150,
+                "temperature": 0.7
+            }
+            
+            response = requests.post(
+                "https://api.deepseek.com/v1/chat/completions",
+                headers=headers,
+                json=data,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                return result['choices'][0]['message']['content'].strip()
+                
+        except Exception as e:
+            logger.error(f"DeepSeek error: {e}")
+        
+        return None
+
+# Initialize AI processor
+ai = SimpleAI()
+
+# ===== VOICE WEBHOOKS =====
+
+@app.route('/voice/incoming', methods=['POST'])
+def handle_voice():
+    """Handle incoming voice calls with iPhone forwarding"""
+    try:
+        if not signalwire_client or not VoiceResponse:
+            return "Service unavailable", 503
+        
+        call_sid = request.form.get('CallSid')
+        from_number = request.form.get('From')
+        to_number = request.form.get('To')
+        forwarded_from = request.form.get('ForwardedFrom')
+        
+        # Detect forwarding
+        is_forwarded = bool(forwarded_from) or (to_number == SIGNALWIRE_PHONE)
+        
+        logger.info(f"📞 Call: {from_number} → {to_number}, Forwarded: {is_forwarded}")
+        
+        # Update stats
+        system_state.increment('calls_today')
+        if is_forwarded:
+            system_state.increment('calls_forwarded')
+        
+        # Store active call
+        system_state.get_all()['active_calls'][call_sid] = {
+            'from': from_number,
+            'forwarded': is_forwarded,
+            'start': datetime.now().isoformat()
+        }
+        
+        response = VoiceResponse()
+        
+        # Greeting
+        if is_forwarded:
+            greeting = "Hi! Thanks for calling Jay's Mobile Wash. I'm Jay's AI assistant ready to help while Jay is with another customer. How can I assist you?"
+        else:
+            greeting = "Hi! Welcome to Jay's Mobile Wash! I'm your AI assistant ready to help with pricing, scheduling, or any questions. How can I help you?"
+        
+        response.say(greeting, voice='alice')
+        
+        # Gather speech
+        response.gather(
+            input='speech',
+            timeout=10,
+            action=f'/voice/process?call_sid={call_sid}&forwarded={is_forwarded}',
+            speech_timeout=3
+        )
+        
+        # Fallback
+        response.say("I didn't catch that. Let me connect you with Jay.", voice='alice')
+        response.dial(JAY_PHONE, timeout=30)
+        
+        return str(response)
+        
+    except Exception as e:
+        logger.error(f"Voice error: {e}")
+        response = VoiceResponse()
+        response.say("Technical issue. Connecting you with Jay.", voice='alice')
+        response.dial(JAY_PHONE, timeout=30)
+        return str(response)
+
+@app.route('/voice/process', methods=['POST'])
+def process_speech():
+    """Process customer speech"""
+    try:
+        call_sid = request.args.get('call_sid')
+        is_forwarded = request.args.get('forwarded') == 'True'
+        speech_result = request.form.get('SpeechResult', '')
+        confidence = float(request.form.get('Confidence', '0.0'))
+        
+        logger.info(f"🎤 Speech: {speech_result} (conf: {confidence:.2f})")
+        
+        if not speech_result or confidence < 0.4:
+            response = VoiceResponse()
+            response.say("I didn't understand clearly. Let me connect you with Jay.", voice='alice')
+            response.dial(JAY_PHONE, timeout=30)
+            return str(response)
+        
+        # Analyze intent
+        intent = ai.detect_intent(speech_result)
+        
+        # Check for escalation
+        if intent in ['urgent', 'human_request'] or 'jay' in speech_result.lower():
+            response = VoiceResponse()
+            response.say("Let me connect you with Jay right away.", voice='alice')
+            response.dial(JAY_PHONE, timeout=30)
+            return str(response)
+        
+        # Generate AI response
+        context = {'forwarded': is_forwarded, 'call_sid': call_sid}
+        ai_response = ai.generate_response(speech_result, context)
+        
+        system_state.increment('ai_responses')
+        
+        response = VoiceResponse()
+        response.say(ai_response, voice='alice')
+        
+        # Continue conversation
+        response.gather(
+            input='speech',
+            timeout=8,
+            action=f'/voice/process?call_sid={call_sid}&forwarded={is_forwarded}',
+            speech_timeout=3
+        )
+        
+        response.say("Thank you for calling Jay's Mobile Wash! Have a great day!", voice='alice')
+        return str(response)
+        
+    except Exception as e:
+        logger.error(f"Speech processing error: {e}")
+        response = VoiceResponse()
+        response.say("Technical issue. Connecting with Jay.", voice='alice')
+        response.dial(JAY_PHONE, timeout=30)
+        return str(response)
+
+# ===== SMS WEBHOOKS =====
+
+@app.route('/sms/incoming', methods=['POST'])
+def handle_sms():
+    """Handle incoming SMS"""
+    try:
+        message_sid = request.form.get('MessageSid')
+        from_number = request.form.get('From')
+        message_body = request.form.get('Body', '').strip()
+        
+        logger.info(f"📱 SMS from {from_number}: {message_body[:50]}...")
+        
+        system_state.increment('sms_today')
+        
+        if not message_body:
+            return send_sms("Hi! How can I help you with Jay's Mobile Wash today?", from_number)
+        
+        # Analyze message
+        intent = ai.detect_intent(message_body)
+        sentiment = ai.analyze_sentiment(message_body)
+        
+        # Check for escalation
+        if (intent in ['urgent', 'human_request'] or 
+            sentiment['score'] < -0.6 or
+            'jay' in message_body.lower()):
+            
+            response_text = f"I'll have Jay respond to you personally. For immediate assistance, call {JAY_PHONE}."
+            # TODO: Notify Jay
+            return send_sms(response_text, from_number)
+        
+        # Generate AI response
+        ai_response = ai.generate_response(message_body, {'sms': True})
+        
+        # Optimize for SMS (160 char limit)
+        if len(ai_response) > 320:
+            ai_response = ai_response[:317] + "..."
+        
+        system_state.increment('ai_responses')
+        
+        return send_sms(ai_response, from_number)
+        
+    except Exception as e:
+        logger.error(f"SMS error: {e}")
+        return send_sms("Thanks for your message! Jay will get back to you soon.", from_number)
+
+def send_sms(message, to_number):
+    """Send SMS response"""
+    try:
+        if signalwire_client:
+            signalwire_client.messages.create(
+                body=message,
+                from_=SIGNALWIRE_PHONE,
+                to=to_number
+            )
+            logger.info(f"📤 SMS sent to {to_number}")
+        
+        return str(MessagingResponse()) if MessagingResponse else ""
+    except Exception as e:
+        logger.error(f"SMS send error: {e}")
+        return ""
+
+# ===== WEB INTERFACE =====
+
+@app.route('/')
+def dashboard():
+    """Main dashboard"""
+    try:
+        stats = system_state.get_all()
+        uptime = datetime.now() - stats['start_time']
+        
+        dashboard_data = {
+            'business_name': BUSINESS_NAME,
+            'jay_phone': JAY_PHONE,
+            'ai_phone': SIGNALWIRE_PHONE,
+            'forwarding_enabled': FORWARDING_ENABLED,
+            'forwarding_delay': FORWARDING_DELAY,
+            'stats': {
+                'calls_today': stats['calls_today'],
+                'sms_today': stats['sms_today'],
+                'calls_forwarded': stats['calls_forwarded'],
+                'ai_responses': stats['ai_responses'],
+                'revenue_today': stats['revenue_today'],
+                'uptime_hours': int(uptime.total_seconds() / 3600),
+                'active_calls': len(stats['active_calls']),
+                'active_sms': len(stats['active_sms']),
+                'status': stats['status']
+            },
+            'services': SERVICES,
+            'signalwire_configured': bool(signalwire_client),
+            'deepseek_configured': bool(DEEPSEEK_API_KEY)
+        }
+        
+        return render_template('dashboard.html', **dashboard_data)
+        
+    except Exception as e:
+        logger.error(f"Dashboard error: {e}")
+        return f"Dashboard error: {e}", 500
+
+@app.route('/api/stats')
+def api_stats():
+    """API endpoint for real-time stats"""
+    stats = system_state.get_all()
+    uptime = datetime.now() - stats['start_time']
+    
+    return jsonify({
+        'calls_today': stats['calls_today'],
+        'sms_today': stats['sms_today'],
+        'calls_forwarded': stats['calls_forwarded'],
+        'ai_responses': stats['ai_responses'],
+        'revenue_today': stats['revenue_today'],
+        'uptime_seconds': int(uptime.total_seconds()),
+        'active_calls': len(stats['active_calls']),
+        'active_sms': len(stats['active_sms']),
+        'status': stats['status'],
+        'timestamp': datetime.now().isoformat()
+    })
+
+@app.route('/health')
+def health_check():
+    """Health check endpoint"""
+    health = {
+        'status': 'healthy',
+        'signalwire': bool(signalwire_client),
+        'deepseek': bool(DEEPSEEK_API_KEY),
+        'uptime': int((datetime.now() - system_state.get_all()['start_time']).total_seconds()),
+        'timestamp': datetime.now().isoformat()
+    }
+    
+    status_code = 200 if health['signalwire'] else 503
+    return jsonify(health), status_code
+
+# ===== SOCKETIO EVENTS =====
+
+@socketio.on('connect')
+def handle_connect():
+    emit('status', {'message': 'Connected to Jay\'s Mobile Wash AI'})
+    logger.info("Client connected")
+
+@socketio.on('request_stats')
+def handle_stats_request():
+    stats = system_state.get_all()
+    emit('stats_update', stats)
+
+# ===== BACKGROUND TASKS =====
+
+def broadcast_stats():
+    """Broadcast stats every 30 seconds"""
+    while True:
+        try:
+            stats = system_state.get_all()
+            socketio.emit('stats_broadcast', stats)
+            time.sleep(30)
+        except Exception as e:
+            logger.error(f"Broadcast error: {e}")
+            time.sleep(60)
+
+# Start background thread
+stats_thread = threading.Thread(target=broadcast_stats, daemon=True)
+stats_thread.start()
+
+# ===== ERROR HANDLERS =====
+
+@app.errorhandler(404)
+def not_found(error):
+    return jsonify({'error': 'Not found'}), 404
+
+@app.errorhandler(500)
+def internal_error(error):
+    logger.error(f"Internal error: {error}")
+    return jsonify({'error': 'Internal server error'}), 500
+
+# ===== STARTUP =====
+
+if __name__ == '__main__':
+    print("\n🚗 JAY'S MOBILE WASH AI SYSTEM")
+    print("=" * 50)
+    print(f"📞 Jay's Phone: {JAY_PHONE}")
+    print(f"🤖 AI Phone: {SIGNALWIRE_PHONE}")
+    print(f"🔄 Forwarding: {'✅ Enabled' if FORWARDING_ENABLED else '❌ Disabled'}")
+    print(f"🌐 SignalWire: {'✅ Connected' if signalwire_client else '❌ Not configured'}")
+    print(f"🧠 DeepSeek: {'✅ Connected' if DEEPSEEK_API_KEY else '❌ Not configured'}")
+    print("=" * 50)
+    print("🚀 Starting server...")
+    
+    # Run the app
+    socketio.run(
+        app,
+        host='0.0.0.0',
+        port=7860,
+        debug=False
+    )