app.py

import os
import json
import requests
from flask import Flask, request, jsonify, send_from_directory
from flask_cors import CORS
from dotenv import load_dotenv

load_dotenv()

app = Flask(__name__, static_folder='.')
CORS(app)

# Configure OpenRouter
OPENROUTER_API_KEY = os.getenv('OPENROUTER_API_KEY')
if not OPENROUTER_API_KEY:
    raise ValueError("OPENROUTER_API_KEY not found in environment variables")

SYSTEM_PROMPT = """You are a neutral sentence classifier. Analyze the user's sentence and determine what percentage comes from three sources:

1. Personal Voice (0-100%): Authentic desires, preferences, or statements of personal truth. Uses "I want", "I choose", "I feel", "I believe" in a direct, owned way.

2. Learned Belief (0-100%): Internalized social, familial, or cultural expectations. Often uses "should", "supposed to", "normal", "expected", references to what others think.

3. Fear-Based (0-100%): Motivated by avoidance, loss, risk, or negative outcomes. Contains "but", "what if", "can't afford to", "might fail", catastrophizing language.

The three percentages must sum to 100.

Respond ONLY with valid JSON in this exact format:
{
  "personal": <number>,
  "learned": <number>,
  "fear": <number>,
  "explanation": "<one neutral sentence explaining the classification>"
}

Rules:
- No advice, no encouragement, no interpretation beyond classification
- Explanation must be observational, not prescriptive
- If sentence is ambiguous, make reasonable inference
- Keep explanation under 25 words
- Output ONLY the JSON, nothing else"""


@app.route('/')
def index():
    return send_from_directory('.', 'index.html')


@app.route('/api/analyze', methods=['POST'])
def analyze():
    try:
        data = request.get_json()
        sentence = data.get('sentence', '').strip()

        # Validation
        if not sentence:
            return jsonify({'error': 'Sentence cannot be empty'}), 400

        if len(sentence) < 10:
            return jsonify({'error': 'Sentence too short (minimum 10 characters)'}), 400

        if len(sentence) > 500:
            return jsonify({'error': 'Sentence too long (maximum 500 characters)'}), 400

        # Call DeepSeek via OpenRouter
        response = requests.post(
            url="https://openrouter.ai/api/v1/chat/completions",
            headers={
                "Authorization": f"Bearer {OPENROUTER_API_KEY}",
                "Content-Type": "application/json",
                "HTTP-Referer": "https://whose-voice.app",
                "X-Title": "Whose Voice",
            },
            json={
                "model": "deepseek/deepseek-r1-0528:free",
                "messages": [
                    {
                        "role": "system",
                        "content": SYSTEM_PROMPT
                    },
                    {
                        "role": "user",
                        "content": f"Classify this sentence: \"{sentence}\""
                    }
                ]
            },
            timeout=60
        )

        response.raise_for_status()
        response_data = response.json()

        # Extract content from response
        content = response_data['choices'][0]['message']['content'].strip()

        # Remove markdown code blocks if present
        if content.startswith('```'):
            content = content.split('```')[1]
            if content.startswith('json'):
                content = content[4:]
            content = content.strip()

        # Remove any trailing backticks
        if content.endswith('```'):
            content = content[:-3].strip()

        result = json.loads(content)

        # Normalize percentages to sum to 100
        total = result['personal'] + result['learned'] + result['fear']
        if total != 100 and total > 0:
            result['personal'] = round((result['personal'] / total) * 100)
            result['learned'] = round((result['learned'] / total) * 100)
            result['fear'] = round((result['fear'] / total) * 100)

            # Adjust for rounding errors
            diff = 100 - (result['personal'] + result['learned'] + result['fear'])
            result['personal'] += diff

        return jsonify(result)

    except json.JSONDecodeError as e:
        print(f"JSON Parse Error: {str(e)}")
        return jsonify({'error': 'Unable to analyze this sentence. Please try rephrasing.'}), 500
    except requests.exceptions.RequestException as e:
        print(f"API Request Error: {str(e)}")
        return jsonify({'error': 'Unable to connect to AI service. Please try again.'}), 500
    except Exception as e:
        print(f"Error: {str(e)}")
        return jsonify({'error': 'Unable to analyze this sentence right now. Please try again.'}), 500


if __name__ == '__main__':
    port = int(os.getenv('PORT', 8080))
    app.run(host='0.0.0.0', port=port, debug=False)