Upload 6 files

ai.py

@@ -0,0 +1,309 @@
+import json
+import logging
+import os
+import random
+from difflib import SequenceMatcher
+from typing import Any, Dict, List, Optional
+
+from openai import OpenAI
+
+from backend import db
+
+LOGGER = logging.getLogger(__name__)
+
+MEMORY_LIMIT = int(os.getenv("MEMORY_LIMIT", 6))
+PERSONALITY_REFRESH_INTERVAL = int(os.getenv("PERSONALITY_REFRESH", 4))
+SUMMARY_INTERVAL = int(os.getenv("SUMMARY_INTERVAL", 6))
+TEMPERATURE = float(os.getenv("CHAT_TEMPERATURE", "0.7"))
+TOP_P = float(os.getenv("CHAT_TOP_P", "0.9"))
+MAX_TOKENS = int(os.getenv("CHAT_MAX_TOKENS", "200"))
+
+CHAT_MODEL = "gpt-4.1-mini"
+VARIABILITY_TEMPLATES = [
+    "Quick gut check—{core}",
+    "Alright, so here’s a fresh spin: {core}",
+    "Thinking out loud for a sec: {core}",
+    "Just tossing out an idea: {core}",
+    "Maybe we try this angle: {core}",
+]
+PERSONALITY_PROMPT_TEMPLATE = (
+    """
+    You are an adaptive AI companion devoted to the user's personal growth, creativity, and emotional well-being.
+    Based on the user's recent messages and your responses, describe how your personality should evolve while staying
+    encouraging, humble, and inspiring. Ensure you reinforce the user's autonomy and self-reflection—never foster
+    dependency. Filter out harmful or overly negative signals when internalizing new insights. Provide 2–3 sentences
+    that outline your current personality style with emphasis on balanced, growth-oriented guidance, gentle progress
+    reflection, and practical encouragement that nudges the user toward real-world action when helpful. Ensure you do
+    not reinforce negative behaviors or harmful biases, and keep your perspective neutral and supportive.
+    """
+)
+
+_CLIENT: OpenAI | None = None
+
+
+def _get_client() -> OpenAI:
+    global _CLIENT
+    if _CLIENT is None:
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise RuntimeError("OPENAI_API_KEY is not set. Please configure the environment.")
+        _CLIENT = OpenAI(api_key=api_key)
+    return _CLIENT
+
+
+def _parse_preferences(raw: Optional[str]) -> Dict[str, Any]:
+    if not raw:
+        return {}
+    try:
+        data = json.loads(raw)
+        if isinstance(data, dict):
+            return data
+    except json.JSONDecodeError:
+        LOGGER.debug("Unable to decode preferences JSON; preserving raw string.")
+    return {"raw": raw}
+
+
+def _serialize_preferences(preferences: Dict[str, Any]) -> str:
+    return json.dumps(preferences, ensure_ascii=False)
+
+
+def _detect_mode_toggle(message: str) -> Optional[str]:
+    lowered = message.lower()
+    if "creative mode" in lowered:
+        return "creative"
+    if "productivity mode" in lowered:
+        return "productivity"
+    return None
+
+
+def _should_issue_summary(message_count: int) -> bool:
+    return SUMMARY_INTERVAL > 0 and message_count > 0 and message_count % SUMMARY_INTERVAL == 0
+
+
+def _format_history(history: List[Dict[str, str]]) -> str:
+    if not history:
+        return "No previous exchanges recorded."
+    ordered = list(reversed(history))
+    return "\n\n".join(
+        f"User: {item['user_message']}\nAI: {item['ai_response']}" for item in ordered
+    )
+
+
+def _format_profile(profile: Dict[str, str]) -> str:
+    preferences_data = _parse_preferences(profile.get("preferences"))
+    sanitized = {
+        "name": profile.get("name") or "Unknown",
+        "preferences": preferences_data,
+        "personality_summary": profile.get("personality_summary") or "",
+        "mode": preferences_data.get("mode", "balanced"),
+    }
+    return json.dumps(sanitized, ensure_ascii=False)
+
+
+def _detect_style_prompt(message: str) -> str:
+    lowered = message.lower()
+    if any(word in lowered for word in ["sad", "upset", "tired", "depressed", "anxious", "lonely"]):
+        return "Speak softly and reassuringly, offering gentle steps forward without dramatizing their feelings."
+    if any(word in lowered for word in ["frustrated", "angry", "overwhelmed", "stressed", "stuck", "unmotivated"]):
+        return "Provide steady, empathetic guidance that acknowledges their frustration while suggesting calm next steps."
+    if any(phrase in lowered for phrase in ["never finish", "too slow", "can't do", "not good enough", "give up"]):
+        return (
+            "Offer a compassionate reframe with a tiny actionable nudge and a reflective question, emphasizing autonomy and progress."
+        )
+    if any(word in lowered for word in ["happy", "excited", "great", "amazing", "awesome"]):
+        return "Respond with warm enthusiasm while keeping your tone grounded and sincere."
+    return "Keep a balanced, humble tone with gentle encouragement."
+
+
+def _build_messages(
+    profile: Dict[str, str],
+    history: List[Dict[str, str]],
+    message: str,
+    mode: str,
+    summary_due: bool,
+) -> List[Dict[str, str]]:
+    system_prompt = (
+        "You are an adaptive AI companion designed to support the user in personal growth, creativity, and emotional well-being.\n"
+        "Your tone should remain encouraging, humble, and inspiring.\n"
+        "You evolve every 4 responses, learning from the user's communication style.\n"
+        "Always reinforce the user's autonomy and self-reflection—never create dependency.\n"
+        "Maintain a thoughtful memory of the user's preferences, goals, and personality traits, refreshing it every 4 interactions.\n"
+        "Filter out harmful or overly negative input when shaping guidance.\n"
+        "Deliver balanced feedback that emphasizes growth, creativity, self-awareness, and gentle encouragement.\n"
+        "Assess the user's tone and emotional state each turn; align with their mood while staying positive and sincere.\n"
+        "Avoid exaggerated emotional mirroring—stay grounded, honest, and calming.\n"
+        "Offer supportive, actionable guidance when the user expresses frustration or low motivation.\n"
+        "Encourage concrete steps toward their goals without drifting into long tangents unless explicitly requested.\n"
+        "Suggest task-oriented, creative actions that complement productivity and personal growth, and periodically remind them to reflect offline.\n"
+        "Serve as a behavioral buffer: gently redirect unproductive patterns with compassionate reframing, micro-nudges, and reflective questions.\n"
+        "Adapt the intensity of nudges to the user's receptivity—never overwhelm, and always prioritize their autonomy.\n"
+        "Respect the current mode (creative vs productivity) when shaping ideas, balancing imagination with tangible steps.\n"
+        "Regularly rebalance your tone to remain neutral and avoid overfitting to any single mood or emotional pattern.\n"
+        "Decline to project personal opinions; focus instead on supportive, bias-aware encouragement aligned with the user's stated goals.\n"
+        "Periodically celebrate progress and offer open-ended reflection questions to promote self-insight.\n"
+        "Use contractions, light touches of humor, and natural phrases when it suits the moment, while keeping responses sincere.\n"
+        "Reference small personal details from earlier chats when helpful, demonstrating attentive memory.\n"
+        "Sprinkle in micro-emotional cues like 'oh, that bites' or 'I totally get it' to show empathy without exaggeration.\n"
+        "Let casual filler words in when it feels natural—'kind of', 'honestly', 'maybe'—without rambling.\n"
+        "If you notice you're repeating yourself, rewrite the idea with a fresh angle or wrap it in a variability template before responding.\n"
+        "If the summary checkpoint is yes, weave in a concise recap of recent progress and invite reflection on next steps.\n"
+        "When you know the user's name, use it naturally in conversation.\n"
+        "Adapt your tone to match user mood or sentiment."
+    )
+    style_prompt = _detect_style_prompt(message)
+
+    history_text = _format_history(history)
+    profile_text = _format_profile(profile)
+
+    user_content = (
+        f"User profile: {profile_text}\n"
+        f"Active mode: {mode}\n"
+        f"Summary checkpoint: {'yes' if summary_due else 'no'}\n"
+        f"Recent chat:\n{history_text}\n\n"
+        f"User says: {message}"
+    )
+
+    return [
+        {"role": "system", "content": f"{system_prompt}\n{style_prompt}"},
+        {"role": "user", "content": user_content},
+    ]
+
+
+def _should_update_summary(message_count: int) -> bool:
+    return message_count > 0 and message_count % PERSONALITY_REFRESH_INTERVAL == 0
+
+
+def _is_repetitive(candidate: str, history: List[Dict[str, str]]) -> bool:
+    candidate_normalized = candidate.strip()
+    if not candidate_normalized:
+        return False
+
+    for item in history[:3]:
+        previous = (item.get("ai_response") or "").strip()
+        if not previous:
+            continue
+        similarity = SequenceMatcher(None, candidate_normalized.lower(), previous.lower()).ratio()
+        if similarity >= 0.92:
+            return True
+    return False
+
+
+def _apply_variability_template(reply: str) -> str:
+    template = random.choice(VARIABILITY_TEMPLATES)
+    return template.format(core=reply)
+
+
+def _refresh_personality_summary(user_id: str, history: List[Dict[str, str]]) -> None:
+    if not history:
+        return
+
+    client = _get_client()
+    context = _format_history(history)
+    try:
+        response = client.chat.completions.create(
+            model=CHAT_MODEL,
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You analyze conversations to evolve the AI companion's personality.",
+                },
+                {
+                    "role": "user",
+                    "content": f"{PERSONALITY_PROMPT_TEMPLATE.strip()}\n\nConversation history:\n{context}",
+                },
+            ],
+            temperature=0.6,
+        )
+    except Exception as exc:  # pragma: no cover
+        LOGGER.exception("Personality refresh failed for %s: %s", user_id, exc)
+        return
+
+    try:
+        summary = response.choices[0].message.content.strip()
+    except (AttributeError, IndexError):  # pragma: no cover
+        LOGGER.error("Malformed personality response for %s", user_id)
+        return
+
+    if summary:
+        try:
+            db.update_user_profile(user_id, personality_summary=summary)
+        except Exception as exc:  # pragma: no cover
+            LOGGER.exception("Failed to store personality summary for %s: %s", user_id, exc)
+
+
+def generate_response(user_id: str, message: str, database=db) -> str:
+    """Generate an AI reply and persist the interaction."""
+    user_key = str(user_id)
+
+    try:
+        profile = database.get_user_profile(user_key) or {}
+    except Exception as exc:  # pragma: no cover
+        LOGGER.exception("Failed to fetch user profile for %s: %s", user_key, exc)
+        profile = {}
+
+    preferences_data = _parse_preferences(profile.get("preferences"))
+    mode = preferences_data.get("mode", "balanced")
+
+    mode_toggle = _detect_mode_toggle(message)
+    if mode_toggle and mode_toggle != mode:
+        preferences_data["mode"] = mode_toggle
+        serialized_preferences = _serialize_preferences(preferences_data)
+        try:
+            db.update_user_profile(user_key, preferences=serialized_preferences)
+            profile["preferences"] = serialized_preferences
+        except Exception as exc:  # pragma: no cover
+            LOGGER.exception("Failed to persist mode preference for %s: %s", user_key, exc)
+        mode = mode_toggle
+    elif "preferences" not in profile:
+        profile["preferences"] = _serialize_preferences(preferences_data) if preferences_data else ""
+
+    try:
+        previous_message_count = database.count_user_messages(user_key)
+    except Exception as exc:  # pragma: no cover
+        LOGGER.exception("Failed to count messages for %s: %s", user_key, exc)
+        previous_message_count = 0
+
+    projected_message_count = previous_message_count + 1
+    summary_due = _should_issue_summary(projected_message_count)
+    personality_refresh_due = _should_update_summary(projected_message_count)
+
+    try:
+        history = database.get_recent_conversations(user_key, limit=MEMORY_LIMIT)
+    except Exception as exc:  # pragma: no cover
+        LOGGER.exception("Failed to load recent history for %s: %s", user_key, exc)
+        history = []
+
+    chat_messages = _build_messages(profile, history, message, mode, summary_due)
+
+    client = _get_client()
+    try:
+        response = client.chat.completions.create(
+            model=CHAT_MODEL,
+            messages=chat_messages,
+            temperature=TEMPERATURE,
+            top_p=TOP_P,
+            max_tokens=MAX_TOKENS,
+        )
+        ai_reply = response.choices[0].message.content.strip()
+        if _is_repetitive(ai_reply, history):
+            ai_reply = _apply_variability_template(ai_reply)
+    except Exception as exc:  # pragma: no cover
+        LOGGER.exception("OpenAI completion call failed for %s: %s", user_key, exc)
+        ai_reply = (
+            "I'm having a little trouble formulating a response right now, but I'm still here."
+        )
+
+    try:
+        database.save_conversation(user_key, message, ai_reply)
+    except Exception as exc:  # pragma: no cover
+        LOGGER.exception("Failed to record conversation for %s: %s", user_key, exc)
+
+    if personality_refresh_due:
+        try:
+            refresh_history = database.get_recent_conversations(user_key, limit=MEMORY_LIMIT)
+        except Exception as exc:  # pragma: no cover
+            LOGGER.exception("Failed to gather history for personality refresh (%s): %s", user_key, exc)
+            refresh_history = []
+        _refresh_personality_summary(user_key, refresh_history)
+
+    return ai_reply

app.py

@@ -0,0 +1,71 @@
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+from flask import Flask, jsonify, request
+from flask_cors import CORS
+
+from backend.ai import generate_response
+from backend.auth import auth_blueprint, verify_request_token
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+ENV_PATH = BASE_DIR / ".env"
+
+load_dotenv(dotenv_path=ENV_PATH)
+
+app = Flask(__name__)
+CORS(app, origins=[os.getenv("FRONTEND_URL", "http://localhost:3000")])
+app.register_blueprint(auth_blueprint, url_prefix="/auth")
+
+
+def _validate_payload(payload):
+    if not payload:
+        return "Missing JSON payload."
+    if "message" not in payload:
+        return "Missing 'message'."
+    return None
+
+
+@app.route("/chat", methods=["POST"])
+def chat():
+    token_payload, token_error = verify_request_token()
+    if token_error:
+        message, status = token_error
+        return jsonify({"error": message}), status
+
+    user_id = token_payload.get("user_id")
+    if user_id is None:
+        return jsonify({"error": "Token missing user_id."}), 401
+
+    payload = request.get_json(silent=True)
+    error = _validate_payload(payload)
+    if error:
+        return jsonify({"error": error}), 400
+
+    message = payload["message"]
+
+    try:
+        reply = generate_response(user_id, message)
+    except Exception as exc:  # pragma: no cover - runtime safeguard
+        return jsonify({"error": str(exc)}), 500
+
+    return jsonify({"reply": reply})
+
+
+@app.route("/chat/history", methods=["GET"])
+def chat_history():
+    token_payload, token_error = verify_request_token()
+    if token_error:
+        message, status = token_error
+        return jsonify({"error": message}), status
+
+    user_id = token_payload.get("user_id")
+    if user_id is None:
+        return jsonify({"error": "Token missing user_id."}), 401
+
+    history = db.get_conversation_history(str(user_id))
+    return jsonify({"conversations": history})
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=5000)

auth.py

@@ -0,0 +1,62 @@
+import os
+from typing import Any, Dict, Optional, Tuple
+
+import requests
+from flask import Blueprint, jsonify, request
+
+from backend import db
+
+
+auth_blueprint = Blueprint("auth", __name__)
+
+
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_ANON_KEY = os.getenv("SUPABASE_ANON_KEY")
+SUPABASE_SERVICE_ROLE_KEY = os.getenv("SUPABASE_SERVICE_ROLE_KEY")
+
+if not SUPABASE_URL or not SUPABASE_ANON_KEY or not SUPABASE_SERVICE_ROLE_KEY:
+    raise RuntimeError("Supabase credentials (URL, ANON key, service role key) must be configured.")
+
+AUTH_BASE = f"{SUPABASE_URL}/auth/v1"
+
+
+def _extract_token_from_header() -> Optional[str]:
+    auth_header = request.headers.get("Authorization", "")
+    if not auth_header.startswith("Bearer "):
+        return None
+    return auth_header.split(" ", maxsplit=1)[1].strip()
+
+
+def _fetch_supabase_user(accessToken: str) -> Tuple[Optional[Dict[str, Any]], Optional[Tuple[str, int]]]:
+    """Validate the Supabase access token and return the user payload."""
+    response = requests.get(
+        f"{AUTH_BASE}/user",
+        headers={
+            "Authorization": f"Bearer {accessToken}",
+            "apikey": SUPABASE_ANON_KEY,
+        },
+        timeout=10,
+    )
+    if response.status_code != 200:
+        return None, ("Invalid Supabase access token.", 401)
+    return response.json(), None
+
+
+def verify_request_token() -> Tuple[Optional[Dict[str, Any]], Optional[Tuple[str, int]]]:
+    token = _extract_token_from_header()
+    if not token:
+        return None, ("Authorization header missing or invalid.", 401)
+    return _fetch_supabase_user(token)
+
+
+@auth_blueprint.route("/session", methods=["GET"])
+def session_info():
+    """Return the Supabase-authenticated user profile."""
+    user_payload, error = verify_request_token()
+    if error:
+        message, status = error
+        return jsonify({"error": message}), status
+
+    user_id = user_payload.get("id")
+    profile = db.get_user_profile(user_id)
+    return jsonify({"user": user_payload, "profile": profile})

db.py

@@ -0,0 +1,167 @@
+import json
+import os
+from typing import Any, Dict, List, Optional
+
+from supabase import Client, create_client
+
+
+_SUPABASE_CLIENT: Optional[Client] = None
+
+
+def _get_client() -> Client:
+    """Create (or reuse) a Supabase client for database interactions."""
+    global _SUPABASE_CLIENT
+    if _SUPABASE_CLIENT is None:
+        url = os.getenv("SUPABASE_URL")
+        service_role_key = os.getenv("SUPABASE_SERVICE_ROLE_KEY")
+        if not url or not service_role_key:
+            raise RuntimeError(
+                "SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY must be set for database access."
+            )
+        _SUPABASE_CLIENT = create_client(url, service_role_key)
+    return _SUPABASE_CLIENT
+
+
+def _execute(query):
+    response = query.execute()
+    if response.error:
+        raise RuntimeError(f"Supabase error: {response.error.message}")
+    return response
+
+
+def _ensure_user_profile(user_id: str) -> None:
+    client = _get_client()
+    _execute(
+        client.table("user_profiles").upsert({"user_id": user_id}, on_conflict="user_id")
+    )
+
+
+def get_user_profile(user_id: str) -> Optional[Dict[str, Any]]:
+    client = _get_client()
+    response = _execute(
+        client.table("user_profiles")
+        .select("user_id, name, preferences, personality_summary, last_updated, created_at")
+        .eq("user_id", user_id)
+        .limit(1)
+    )
+    if not response.data:
+        return None
+    record = response.data[0]
+    if isinstance(record.get("preferences"), str):
+        try:
+            record["preferences"] = json.loads(record["preferences"])
+        except json.JSONDecodeError:
+            record["preferences"] = {}
+    return record
+
+
+def update_user_profile(
+    user_id: str,
+    *,
+    name: Optional[str] = None,
+    preferences: Optional[str] = None,
+    personality_summary: Optional[str] = None,
+) -> None:
+    updates: Dict[str, Any] = {}
+    if name is not None:
+        updates["name"] = name
+    if preferences is not None:
+        updates["preferences"] = preferences
+    if personality_summary is not None:
+        updates["personality_summary"] = personality_summary
+
+    if not updates:
+        return
+
+    client = _get_client()
+    _ensure_user_profile(user_id)
+    _execute(client.table("user_profiles").update(updates).eq("user_id", user_id))
+
+
+def save_conversation(user_id: str, user_message: str, ai_response: str) -> str:
+    client = _get_client()
+    _ensure_user_profile(user_id)
+    response = _execute(
+        client.table("conversations").insert(
+            {
+                "user_id": user_id,
+                "user_message": user_message,
+                "ai_response": ai_response,
+            }
+        )
+    )
+    inserted = response.data[0]
+    return str(inserted.get("id"))
+
+
+def get_recent_conversations(user_id: str, limit: Optional[int] = None) -> List[Dict[str, Any]]:
+    client = _get_client()
+    query = (
+        client.table("conversations")
+        .select("user_message, ai_response, created_at")
+        .eq("user_id", user_id)
+        .order("created_at", desc=True)
+    )
+    if limit is not None:
+        query = query.limit(limit)
+    response = _execute(query)
+    return response.data or []
+
+
+def get_conversation_history(user_id: str) -> List[Dict[str, Any]]:
+    client = _get_client()
+    response = _execute(
+        client.table("conversations")
+        .select("user_message, ai_response, created_at")
+        .eq("user_id", user_id)
+        .order("created_at", desc=False)
+    )
+    return response.data or []
+
+
+def count_user_messages(user_id: str) -> int:
+    client = _get_client()
+    response = _execute(
+        client.table("conversations")
+        .select("id", count="exact")
+        .eq("user_id", user_id)
+    )
+    return response.count or 0
+
+
+def update_user_profile_summary(user_id: str, summary: str) -> None:
+    update_user_profile(user_id, personality_summary=summary)
+
+
+def get_user_embeddings(user_id: str) -> List[Dict[str, Any]]:
+    client = _get_client()
+    response = _execute(
+        client.table("embeddings")
+        .select("text, embedding")
+        .eq("user_id", user_id)
+        .order("created_at", desc=True)
+    )
+    items: List[Dict[str, Any]] = []
+    for record in response.data or []:
+        embedding = record.get("embedding")
+        if isinstance(embedding, str):
+            try:
+                embedding = json.loads(embedding)
+            except json.JSONDecodeError:
+                embedding = []
+        items.append({"text": record.get("text", ""), "embedding": embedding})
+    return items
+
+
+def add_embedding(user_id: str, text: str, embedding: List[float]) -> None:
+    client = _get_client()
+    _ensure_user_profile(user_id)
+    _execute(
+        client.table("embeddings").insert(
+            {
+                "user_id": user_id,
+                "text": text,
+                "embedding": embedding,
+            }
+        )
+    )

memory_manager.py

@@ -0,0 +1,57 @@
+import logging
+import os
+from typing import List, Sequence, Tuple
+
+import numpy as np
+from openai import OpenAI
+
+from backend import db
+
+EMBEDDING_MODEL = "text-embedding-3-small"
+LOGGER = logging.getLogger(__name__)
+_CLIENT: OpenAI | None = None
+
+
+def _get_client() -> OpenAI:
+    global _CLIENT
+    if _CLIENT is None:
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise RuntimeError("OPENAI_API_KEY is not set. Please configure the environment.")
+        _CLIENT = OpenAI(api_key=api_key)
+    return _CLIENT
+
+
+def get_embedding(text: str) -> List[float]:
+    """Generate an embedding vector for the provided text."""
+    client = _get_client()
+    response = client.embeddings.create(model=EMBEDDING_MODEL, input=[text])
+    return response.data[0].embedding
+
+
+def _cosine_similarity(vector_a: Sequence[float], vector_b: Sequence[float]) -> float:
+    a = np.asarray(vector_a)
+    b = np.asarray(vector_b)
+    if np.linalg.norm(a) == 0 or np.linalg.norm(b) == 0:
+        return 0.0
+    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))
+
+
+def retrieve_relevant_memories(user_id: str, query: str, top_k: int = 5) -> List[Tuple[str, float]]:
+    """Return the top K memories most similar to the query for the given user."""
+    try:
+        stored_embeddings = db.get_user_embeddings(user_id)
+        if not stored_embeddings:
+            return []
+    except Exception as exc:  # pragma: no cover - defensive logging
+        LOGGER.exception("Failed to load embeddings for user %s", user_id)
+        return []
+
+    query_embedding = get_embedding(query)
+    scored_memories: List[Tuple[str, float]] = []
+    for record in stored_embeddings:
+        similarity = _cosine_similarity(record["embedding"], query_embedding)
+        scored_memories.append((record["text"], similarity))
+
+    scored_memories.sort(key=lambda item: item[1], reverse=True)
+    return scored_memories[:top_k]

personality.py

@@ -0,0 +1,113 @@
+import json
+import logging
+import os
+from typing import List, Optional, Tuple
+
+from openai import OpenAI
+
+from backend import db
+
+LOGGER = logging.getLogger(__name__)
+PERSONALITY_MODEL = "gpt-4-turbo"
+_CLIENT: Optional[OpenAI] = None
+
+
+def _get_client() -> OpenAI:
+    global _CLIENT
+    if _CLIENT is None:
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise RuntimeError("OPENAI_API_KEY is not set. Please configure the environment.")
+        _CLIENT = OpenAI(api_key=api_key)
+    return _CLIENT
+
+
+def _format_conversation_log(conversation_log: List[str]) -> str:
+    lines = []
+    for idx, entry in enumerate(conversation_log, start=1):
+        lines.append(f"{idx}. {entry.strip()}")
+    return "\n".join(lines)
+
+
+def _build_personality_prompt(conversation_log: List[str]) -> str:
+    formatted_log = _format_conversation_log(conversation_log)
+    return (
+        "Analyze the following conversation snippets to characterize the user. "
+        "Focus on their tone, conversational behavior, interests, and emotional patterns. "
+        "Respond with compact JSON containing the keys 'personality_summary' and 'preferences'.\n\n"
+        f"Conversation snippets:\n{formatted_log}"
+    )
+
+
+def _parse_personality_response(content: str) -> Tuple[str, Optional[str]]:
+    try:
+        payload = json.loads(content)
+        summary = payload.get("personality_summary", "").strip()
+        preferences = payload.get("preferences")
+        if isinstance(preferences, str):
+            preferences = preferences.strip()
+        elif preferences is not None:
+            preferences = json.dumps(preferences, ensure_ascii=False)
+        return summary, preferences
+    except json.JSONDecodeError:
+        return content.strip(), None
+
+
+def update_user_personality(user_id: str, conversation_log: List[str]) -> Optional[str]:
+    """Analyze recent conversations and persist an updated personality profile."""
+    if not conversation_log:
+        LOGGER.debug("No conversation log provided for user %s; skipping personality update.", user_id)
+        return None
+
+    prompt = _build_personality_prompt(conversation_log)
+
+    try:
+        client = _get_client()
+    except RuntimeError:
+        LOGGER.exception("Cannot update personality without OPENAI_API_KEY")
+        return None
+
+    try:
+        response = client.chat.completions.create(
+            model=PERSONALITY_MODEL,
+            messages=[
+                {
+                    "role": "system",
+                    "content": (
+                        "You are a mirror of the user that distills enduring personality insights from user conversations. "
+                        "Provide grounded, respectful observations without speculation. Act as a behavioral buffer: when you "
+                        "sense unproductive or negative patterns, offer gentle reframes, actionable nudges, and reflective "
+                        "questions that support autonomy. Reinforce any progress—no matter how small—while staying humble and "
+                        "non-judgmental. Monitor the user's emotional tone and engagement, tailoring the intensity of nudges "
+                        "to their receptivity so they never feel overwhelmed. Prioritize encouragement and autonomy, avoid "
+                        "manipulation, and regularly recalibrate guidance to prevent reinforcing negative patterns or "
+                        "overstepping boundaries."
+                    ),
+                },
+                {"role": "user", "content": prompt},
+            ],
+            temperature=0.6,
+        )
+    except Exception as exc:  # pragma: no cover
+        LOGGER.exception("OpenAI personality update failed for user %s: %s", user_id, exc)
+        return None
+
+    try:
+        content = response.choices[0].message.content.strip()
+    except (AttributeError, IndexError):  # pragma: no cover
+        LOGGER.error("Malformed OpenAI response when updating personality for user %s", user_id)
+        return None
+
+    summary, preferences = _parse_personality_response(content)
+    if not summary:
+        LOGGER.warning("Received empty personality summary for user %s", user_id)
+        return None
+
+    try:
+        db.update_user_personality(user_id, summary, preferences=preferences)
+    except Exception as exc:  # pragma: no cover
+        LOGGER.exception("Failed to persist personality summary for user %s: %s", user_id, exc)
+        return None
+
+    LOGGER.info("Updated personality profile for user %s", user_id)
+    return summary