@innvisor/conny-ai 9.7.0

package/conny_smart_features.py

@@ -0,0 +1,333 @@
+"""conny_smart_features.py — 10 power features for human-like intelligence."""
+from __future__ import annotations
+import json, logging, re, time
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+log = logging.getLogger("conny.smart")
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 1. CROSS-SESSION MEMORY — Remember patients by phone number
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class CrossSessionMemory:
+    """Remember patient context across multiple conversations."""
+
+    def __init__(self, instance_id: str = "default"):
+        self._dir = Path(f"memory_store/{instance_id}/patients")
+        self._dir.mkdir(parents=True, exist_ok=True)
+
+    def remember_patient(self, chat_id: str, data: Dict):
+        """Store patient data (name, preferences, last topic)."""
+        file = self._dir / f"{self._safe_id(chat_id)}.json"
+        existing = json.loads(file.read_text()) if file.exists() else {}
+        existing.update(data)
+        existing["last_seen"] = datetime.now().isoformat()
+        existing["visit_count"] = existing.get("visit_count", 0) + 1
+        file.write_text(json.dumps(existing, ensure_ascii=False, indent=2))
+
+    def recall_patient(self, chat_id: str) -> Dict:
+        """Recall everything we know about this patient."""
+        file = self._dir / f"{self._safe_id(chat_id)}.json"
+        if file.exists():
+            return json.loads(file.read_text())
+        return {}
+
+    def get_context_for_prompt(self, chat_id: str) -> str:
+        """Build a prompt section with patient memory."""
+        data = self.recall_patient(chat_id)
+        if not data:
+            return ""
+        parts = []
+        if data.get("name"):
+            parts.append(f"Se llama {data['name']}")
+        if data.get("last_topic"):
+            parts.append(f"La última vez habló de: {data['last_topic']}")
+        if data.get("visit_count", 0) > 1:
+            parts.append(f"Ya ha escrito {data['visit_count']} veces")
+        if data.get("preferences"):
+            parts.append(f"Preferencias: {data['preferences']}")
+        return "\n".join(parts) if parts else ""
+
+    def _safe_id(self, chat_id: str) -> str:
+        return chat_id.replace("@", "_").replace(".", "_")[:50]
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 2. FOLLOW-UP ENGINE — Re-engage abandoned conversations
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class FollowUpEngine:
+    """Schedule and manage follow-up messages."""
+
+    def __init__(self, instance_id: str = "default"):
+        self._file = Path(f"memory_store/{instance_id}/followups.jsonl")
+        self._file.parent.mkdir(parents=True, exist_ok=True)
+
+    def schedule_followup(self, chat_id: str, reason: str, delay_hours: int = 24):
+        """Schedule a follow-up message."""
+        entry = {
+            "chat_id": chat_id,
+            "reason": reason,
+            "send_after": (datetime.now() + timedelta(hours=delay_hours)).isoformat(),
+            "sent": False,
+        }
+        with open(self._file, "a") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+    def get_pending_followups(self) -> List[Dict]:
+        """Get all follow-ups that are due."""
+        if not self._file.exists():
+            return []
+        now = datetime.now().isoformat()
+        pending = []
+        for line in open(self._file):
+            try:
+                entry = json.loads(line)
+                if not entry.get("sent") and entry.get("send_after", "") <= now:
+                    pending.append(entry)
+            except Exception:
+                continue
+        return pending
+
+    def generate_followup_message(self, reason: str) -> str:
+        """Generate a natural follow-up message."""
+        templates = {
+            "pricing": "hola! ayer estuvimos hablando de precios, te quedó alguna duda?",
+            "booking": "hey! me quedé pensando en tu cita, quieres que te ayude a agendar?",
+            "info": "hola de nuevo! por si te sirve, aquí estoy para lo que necesites",
+            "default": "hola! hace rato no hablamos, necesitas algo?",
+        }
+        return templates.get(reason, templates["default"])
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 3. SENTIMENT TRACKER — Detect emotional state per turn
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class SentimentTracker:
+    """Track patient sentiment across conversation turns."""
+
+    FRUSTRATED = ["no entiendo", "ya le dije", "otra vez", "no me sirve", "eso no",
+                  "qué lento", "cuánto más", "pésimo", "malo", "horrible"]
+    HAPPY = ["gracias", "perfecto", "genial", "excelente", "increíble", "súper",
+             "te amo", "la mejor", "mil gracias", "buenísimo"]
+    URGENT = ["urgente", "emergencia", "ayuda", "ya", "rápido", "ahora mismo",
+              "sangre", "dolor", "grave", "auxilio"]
+
+    def analyze(self, text: str) -> Dict[str, float]:
+        """Return sentiment scores."""
+        t = text.lower()
+        return {
+            "frustration": sum(1 for w in self.FRUSTRATED if w in t) / max(len(self.FRUSTRATED), 1),
+            "happiness": sum(1 for w in self.HAPPY if w in t) / max(len(self.HAPPY), 1),
+            "urgency": sum(1 for w in self.URGENT if w in t) / max(len(self.URGENT), 1),
+        }
+
+    def should_escalate(self, text: str, history: List[Dict] = None) -> Tuple[bool, str]:
+        """Determine if conversation should escalate to human."""
+        scores = self.analyze(text)
+        if scores["urgency"] > 0.2:
+            return True, "urgency_detected"
+        if scores["frustration"] > 0.15:
+            # Check if frustrated for multiple turns
+            if history and len(history) >= 4:
+                recent_frustration = sum(
+                    self.analyze(m.get("content", ""))["frustration"]
+                    for m in history[-4:] if m.get("role") == "user"
+                )
+                if recent_frustration > 0.3:
+                    return True, "sustained_frustration"
+        return False, ""
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 4. PREDICTIVE INTENT — Know what returning patients want
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class PredictiveIntent:
+    """Predict what a returning patient wants."""
+
+    def predict(self, patient_memory: Dict, current_msg: str) -> Optional[str]:
+        """Predict intent based on history."""
+        last_topic = patient_memory.get("last_topic", "")
+        visit_count = patient_memory.get("visit_count", 0)
+
+        msg_low = current_msg.lower().strip()
+
+        # Simple greeting from returning patient → probably wants to continue
+        if msg_low in ("hola", "buenas", "hey", "hola buenas") and visit_count > 1:
+            if last_topic == "pricing":
+                return "returning_for_booking"
+            if last_topic == "booking":
+                return "checking_appointment"
+
+        return None
+
+    def get_proactive_opener(self, prediction: str, patient_name: str = "") -> Optional[str]:
+        """Get a proactive opening based on prediction."""
+        name = patient_name or ""
+        openers = {
+            "returning_for_booking": f"hola{' ' + name if name else ''}! la otra vez estuvimos mirando precios, quieres que agendemos?",
+            "checking_appointment": f"hola{' ' + name if name else ''}! vienes por lo de tu cita?",
+        }
+        return openers.get(prediction)
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 5. TIME AWARENESS — Greet appropriately for Colombian time
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def get_time_greeting() -> str:
+    """Return appropriate greeting for current Colombian time (UTC-5)."""
+    from datetime import timezone
+    now = datetime.now(timezone(timedelta(hours=-5)))
+    hour = now.hour
+    if 5 <= hour < 12:
+        return "buenos días"
+    elif 12 <= hour < 18:
+        return "buenas tardes"
+    else:
+        return "buenas noches"
+
+
+def is_business_hours() -> bool:
+    """Check if it's currently business hours in Colombia."""
+    from datetime import timezone
+    now = datetime.now(timezone(timedelta(hours=-5)))
+    return 8 <= now.hour <= 18 and now.weekday() < 6
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 6. CONVERSATION CLOSER — Detect natural end
+# ═══════════════════════════════════════════════════════════════════════════════
+
+CLOSING_SIGNALS = [
+    "gracias", "chao", "bye", "hasta luego", "nos vemos",
+    "listo", "perfecto gracias", "dale gracias", "ok gracias",
+    "bendiciones", "que estés bien", "buena tarde", "buena noche",
+]
+
+def is_conversation_ending(text: str) -> bool:
+    """Detect if the patient is saying goodbye."""
+    t = text.lower().strip()
+    return any(signal in t for signal in CLOSING_SIGNALS)
+
+def get_natural_closing(tone: str = "casual") -> str:
+    """Generate a natural conversation closing."""
+    import random
+    closings = {
+        "casual": ["dale, cualquier cosa me escribes!", "listo, aquí estoy pa lo que necesites", "chao, que te vaya bien!"],
+        "luxury": ["fue un placer atenderle, que tenga un excelente día", "quedamos atentos para servirle, que esté muy bien"],
+        "formal": ["con gusto, que tenga buen día", "quedamos pendientes, hasta pronto"],
+    }
+    options = closings.get(tone, closings["casual"])
+    return random.choice(options)
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 7. POST-VISIT FOLLOW-UP — Request reviews after appointment
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def generate_review_request(patient_name: str = "", clinic_name: str = "", google_review_link: str = "") -> str:
+    """Generate a natural review request message."""
+    name = patient_name or ""
+    greeting = f"hola{' ' + name if name else ''}!"
+
+    if google_review_link:
+        return f"{greeting} cómo te fue en tu cita? espero que todo bien\n\nsi te gustó la atención, nos ayudaría muchísimo una reseñita aquí: {google_review_link}\n\ngracias!"
+    return f"{greeting} cómo te fue en tu cita? espero que todo super bien"
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 8. WEEKLY STATS — Count everything
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class WeeklyStats:
+    """Calculate weekly statistics for an instance."""
+
+    def calculate(self, db_path: str = "conny.db") -> Dict[str, int]:
+        """Get stats for the last 7 days."""
+        import sqlite3
+        try:
+            conn = sqlite3.connect(db_path)
+            c = conn.cursor()
+            week_ago = (datetime.now() - timedelta(days=7)).isoformat()
+
+            c.execute("SELECT COUNT(DISTINCT chat_id) FROM conversations WHERE role='user' AND created_at > ?", (week_ago,))
+            patients = c.fetchone()[0] or 0
+
+            c.execute("SELECT COUNT(*) FROM conversations WHERE created_at > ?", (week_ago,))
+            messages = c.fetchone()[0] or 0
+
+            conn.close()
+            return {"patients": patients, "messages": messages, "period": "7d"}
+        except Exception:
+            return {"patients": 0, "messages": 0, "period": "7d"}
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 9. ADMIN SHADOW MODE — Learn from admin's real responses
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class AdminShadowMode:
+    """When admin takes over a conversation, learn from their responses."""
+
+    def __init__(self, instance_id: str = "default"):
+        self._instance_id = instance_id
+        self._shadow_file = Path(f"soul/{instance_id}/shadow_learnings.jsonl")
+        self._shadow_file.parent.mkdir(parents=True, exist_ok=True)
+
+    def detect_admin_takeover(self, chat_id: str, admin_ids: List[str], message_sender: str) -> bool:
+        """Detect if admin is responding to a patient's chat."""
+        # If message is outgoing (fromMe) in a non-admin chat, admin took over
+        return message_sender in admin_ids and chat_id not in admin_ids
+
+    def learn_from_admin_response(self, patient_question: str, admin_response: str):
+        """Save admin's response as a learning example."""
+        entry = {
+            "ts": datetime.now().isoformat(),
+            "patient_asked": patient_question[:200],
+            "admin_responded": admin_response[:500],
+            "learned": True,
+        }
+        with open(self._shadow_file, "a") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+        log.info(f"[shadow] learned from admin: {patient_question[:50]} → {admin_response[:50]}")
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 10. LANGUAGE DETECTOR — Auto-detect and respond in same language
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class LanguageDetector:
+    """Simple keyword-based language detection."""
+
+    ENGLISH_MARKERS = ["hello", "hi", "good morning", "how are you", "i want", "i need",
+                       "please", "thank you", "appointment", "available", "price"]
+    PORTUGUESE_MARKERS = ["olá", "bom dia", "boa tarde", "quero", "preciso",
+                          "por favor", "obrigado", "consulta", "disponível", "preço"]
+
+    def detect(self, text: str) -> str:
+        """Detect language: es, en, or pt."""
+        t = text.lower()
+        en_score = sum(1 for m in self.ENGLISH_MARKERS if m in t)
+        pt_score = sum(1 for m in self.PORTUGUESE_MARKERS if m in t)
+
+        if en_score >= 2:
+            return "en"
+        if pt_score >= 2:
+            return "pt"
+        if en_score == 1 and not any(w in t for w in ["hola", "buenas", "quiero"]):
+            return "en"
+        return "es"
+
+    def get_language_instruction(self, lang: str) -> str:
+        """Get system prompt instruction for detected language."""
+        if lang == "en":
+            return "The patient is writing in English. Respond entirely in English. Natural, warm tone."
+        if lang == "pt":
+            return "O paciente está escrevendo em português. Responda totalmente em português brasileiro."
+        return ""

package/conny_studio.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""conny_studio.py — Interactive CLI session with live monitoring."""
+import asyncio
+import json
+import os
+import sys
+import time
+import uuid
+from pathlib import Path
+from datetime import datetime
+
+import httpx
+
+sys.path.insert(0, str(Path(__file__).parent))
+from conny_uncertainty import UncertaintyDetector
+from conny_voice import ConnyVoice
+
+STUDIO_DIR = Path.home() / ".conny" / "studio" / "memory"
+API_URL = "http://localhost:8001/test"
+
+
+class ConnyStudio:
+    def __init__(self, instance_id="default", master_key=None):
+        self.instance_id = instance_id
+        self.session_id = datetime.now().strftime("%Y%m%d_%H%M%S") + "_" + uuid.uuid4().hex[:6]
+        self.session_dir = STUDIO_DIR / self.session_id
+        self.session_dir.mkdir(parents=True, exist_ok=True)
+        self.turns_file = self.session_dir / "turns.jsonl"
+        self.failures_file = self.session_dir / "failures.jsonl"
+        self.uncertainty = UncertaintyDetector()
+        self.voice = ConnyVoice()
+        self.master_key = master_key or os.getenv("MASTER_API_KEY", "conny_master_2026_santiago")
+        self.history = []
+        self.chat_id = f"studio_{self.session_id}"
+
+    async def send_message(self, text: str) -> dict:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            r = await client.post(
+                API_URL,
+                json={"message": text, "chat_id": self.chat_id},
+                headers={"X-Master-Key": self.master_key, "Content-Type": "application/json"},
+            )
+            return r.json()
+
+    def score_response(self, response: str, user_msg: str) -> dict:
+        confidence = self.uncertainty.confidence_score(response, user_msg, self.history)
+        robot_patterns = self.voice.check_robot_patterns(response)
+        has_uncertainty = self.uncertainty.detect_uncertainty_markers(response)
+        return {
+            "confidence": round(confidence, 2),
+            "robot_patterns": robot_patterns,
+            "has_uncertainty": has_uncertainty,
+            "human_score": round(max(0, 1.0 - len(robot_patterns) * 0.2 - (0.3 if has_uncertainty else 0)), 2),
+        }
+
+    def save_turn(self, user_msg, bot_response, scores):
+        turn = {"ts": datetime.now().isoformat(), "user": user_msg, "bot": bot_response, "scores": scores}
+        with open(self.turns_file, "a") as f:
+            f.write(json.dumps(turn, ensure_ascii=False) + "\n")
+        self.history.append({"role": "user", "content": user_msg})
+        self.history.append({"role": "assistant", "content": bot_response})
+        if scores["confidence"] < 0.6 or scores["robot_patterns"]:
+            with open(self.failures_file, "a") as f:
+                f.write(json.dumps({
+                    "ts": datetime.now().isoformat(),
+                    "type": "low_confidence" if scores["confidence"] < 0.6 else "robot_speech",
+                    "response": bot_response[:200],
+                    "scores": scores,
+                }, ensure_ascii=False) + "\n")
+
+    async def handle_command(self, cmd: str) -> str:
+        if cmd == "/clear":
+            self.history = []
+            self.chat_id = f"studio_{uuid.uuid4().hex[:8]}"
+            return "Session cleared. New conversation started."
+        elif cmd == "/show-memory":
+            if not self.history:
+                return "No turns in memory yet."
+            lines = []
+            for h in self.history[-10:]:
+                role = "YOU" if h["role"] == "user" else "MEL"
+                lines.append(f"  [{role}] {h['content'][:80]}")
+            return "\n".join(lines)
+        elif cmd == "/show-failures":
+            if not self.failures_file.exists():
+                return "No failures detected this session."
+            lines = []
+            for line in open(self.failures_file):
+                f = json.loads(line)
+                lines.append(f"  [{f['type']}] {f['response'][:60]}... (conf: {f['scores']['confidence']})")
+            return "\n".join(lines[-10:]) if lines else "No failures."
+        elif cmd == "/reload-persona":
+            return "Persona reloaded from runtime_override.json"
+        elif cmd == "/export-session":
+            return f"Session exported to: {self.session_dir}"
+        elif cmd.startswith("/fix-last"):
+            if len(self.history) >= 2:
+                last_user = self.history[-2]["content"]
+                result = await self.send_message(last_user)
+                return f"Regenerated: {result.get('response', 'error')[:200]}"
+            return "No previous turn to fix."
+        return f"Unknown command: {cmd}"
+
+    def print_header(self):
+        print("\033[1;36m╔══════════════════════════════════════════════╗\033[0m")
+        print("\033[1;36m║  CONNY STUDIO v1.0                         ║\033[0m")
+        print(f"\033[1;36m║  Instance: {self.instance_id:<33}║\033[0m")
+        print(f"\033[1;36m║  Session: {self.session_id:<34}║\033[0m")
+        print("\033[1;36m╚══════════════════════════════════════════════╝\033[0m")
+        print("\033[90mCommands: /clear /show-memory /show-failures /fix-last /reload-persona /export-session\033[0m\n")
+
+    def print_scores(self, scores):
+        conf = scores["confidence"]
+        conf_color = "\033[32m" if conf >= 0.7 else ("\033[33m" if conf >= 0.5 else "\033[31m")
+        icon = "✓" if conf >= 0.7 else ("~" if conf >= 0.5 else "✗")
+        robot_count = len(scores["robot_patterns"])
+        print(f"  \033[90m├─ Confidence: {conf_color}{conf:.2f} {icon}\033[0m")
+        print(f"  \033[90m├─ Human score: {scores['human_score']:.2f}\033[0m")
+        print(f"  \033[90m└─ Robot patterns: {robot_count} {'✓' if robot_count == 0 else '⚠'}\033[0m")
+
+    async def run(self):
+        self.print_header()
+        while True:
+            try:
+                user_input = input("\033[1;32m[YOU]\033[0m ")
+            except (EOFError, KeyboardInterrupt):
+                print("\n\033[90mSession ended.\033[0m")
+                break
+            if not user_input.strip():
+                continue
+            if user_input.startswith("/"):
+                result = await self.handle_command(user_input.strip())
+                print(f"\033[1;33m[SYSTEM]\033[0m {result}")
+                continue
+            try:
+                result = await self.send_message(user_input)
+                response = result.get("response", "")
+                bubbles = result.get("bubbles", [response])
+            except Exception as e:
+                print(f"\033[31m[ERROR] {e}\033[0m")
+                continue
+            for bubble in bubbles:
+                print(f"\033[1;35m[CONNY]\033[0m {bubble}")
+            scores = self.score_response(response, user_input)
+            self.print_scores(scores)
+            self.save_turn(user_input, response, scores)
+            print()
+
+
+async def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Conny Studio — Interactive chat with monitoring")
+    parser.add_argument("--instance", default="default", help="Instance ID")
+    parser.add_argument("--key", default=None, help="Master API key")
+    args = parser.parse_args()
+    studio = ConnyStudio(instance_id=args.instance, master_key=args.key)
+    await studio.run()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())