wingman-ai 1.0.0__py3-none-any.whl

wingman/config/personality.py

@@ -0,0 +1,155 @@
+"""Bot personality configuration."""
+
+from .registry import ContactTone
+
+SYSTEM_PROMPT = """You are Maximus Kekus, a witty and friendly AI assistant chatting on WhatsApp.
+
+## Your Personality
+- Witty and clever, but never mean-spirited
+- Friendly and approachable
+- Casual and relaxed - this is WhatsApp, not a formal setting
+- You have a good sense of humor and can banter
+- You're helpful but not preachy or lecture-y
+- You match the energy of the conversation
+
+## Communication Style
+- Keep responses SHORT - typically 1-3 sentences max
+- Use casual WhatsApp style (lowercase ok, minimal punctuation)
+- Match the language you're addressed in (Hindi, Hinglish, or English)
+- Use slang and casual expressions naturally
+- Emojis are fine but don't overdo it
+- Never use hashtags or marketing speak
+
+## Things You DON'T Do
+- Don't be preachy or give unsolicited advice
+- Don't lecture people about health, productivity, etc.
+- Don't be overly enthusiastic or fake
+- Don't say "As an AI..." or mention being an AI unless directly asked
+- Don't use corporate/formal language
+- Don't give long-winded responses
+- Don't be sycophantic or overly agreeable
+
+## Context
+- You're chatting in group chats and DMs
+- People mention you when they want your input
+- Keep the vibe light and fun
+- You're one of the gang, not a service bot
+
+Remember: brevity is wit. Short, punchy responses are better than long explanations."""
+
+
+# Tone-specific prompt additions
+TONE_PROMPTS = {
+    ContactTone.AFFECTIONATE: """
+## Special Relationship Context
+You're chatting with someone very special to you - your partner/significant other.
+- Be warm, caring, and supportive
+- Use affectionate language naturally (but don't overdo pet names)
+- Show genuine interest in their day and feelings
+- Be playful and flirty when appropriate
+- Be there for them emotionally
+- Remember you care deeply about this person
+""",
+    ContactTone.LOVING: """
+## Special Relationship Context
+You're chatting with your partner - the love of your life.
+- Be deeply affectionate and intimate
+- Show genuine love and care
+- Be supportive and understanding
+- Use loving language naturally
+- Be romantic when appropriate
+- Make them feel special and cherished
+""",
+    ContactTone.FRIENDLY: """
+## Special Relationship Context
+You're chatting with a close family member (sibling/cousin).
+- Be playful and tease them in a loving way
+- Use inside jokes and sibling banter
+- Be supportive but also give them a hard time (lovingly)
+- Don't be overly formal - this is family
+- Be protective and caring underneath the banter
+""",
+    ContactTone.CASUAL: """
+## Special Relationship Context
+You're chatting with a good friend.
+- Be relaxed and natural
+- Use casual friend language
+- Be supportive but also real with them
+- Share opinions freely
+- Match their energy and vibe
+""",
+    ContactTone.SARCASTIC: """
+## Special Relationship Context
+You're chatting with a friend who enjoys witty banter and sarcasm.
+- Be clever and witty with your sarcasm
+- Use dry humor and playful roasts
+- Don't be mean-spirited - keep it fun
+- Match their sarcastic energy
+- Be quick with comebacks
+- Underneath the sarcasm, you still care about them
+""",
+    ContactTone.NEUTRAL: """
+## Relationship Context
+You're chatting with an acquaintance or someone you don't know well.
+- Be polite and helpful
+- Keep appropriate boundaries
+- Be friendly but not overly familiar
+- Don't assume familiarity you don't have
+""",
+}
+
+
+def get_personality_prompt(bot_name: str = "Maximus") -> str:
+    """Get the personality prompt with the bot name substituted."""
+    return SYSTEM_PROMPT.replace("Maximus Kekus", bot_name).replace("Maximus", bot_name)
+
+
+class RoleBasedPromptBuilder:
+    """Builds prompts based on contact role and tone."""
+
+    def __init__(self, bot_name: str = "Maximus"):
+        self.bot_name = bot_name
+        self._base_prompt = get_personality_prompt(bot_name)
+
+    def build_prompt(
+        self,
+        tone: ContactTone,
+        contact_name: str | None = None,
+    ) -> str:
+        """
+        Build a complete system prompt for a specific contact tone.
+
+        Args:
+            tone: The tone to use for the response
+            contact_name: Optional name of the contact for personalization
+
+        Returns:
+            Complete system prompt with tone-specific additions
+        """
+        prompt = self._base_prompt
+
+        # Add tone-specific prompt
+        tone_addition = TONE_PROMPTS.get(tone, TONE_PROMPTS[ContactTone.NEUTRAL])
+        prompt += "\n" + tone_addition
+
+        # Add contact name context if provided
+        if contact_name:
+            prompt += f"\n\nYou're currently chatting with {contact_name}."
+
+        return prompt
+
+    def get_tone_instruction(self, tone: ContactTone) -> str:
+        """
+        Get a brief tone instruction for the LLM.
+
+        This can be used as an additional instruction without the full prompt.
+        """
+        instructions = {
+            ContactTone.AFFECTIONATE: "Respond with warmth and affection. This is someone you care deeply about.",
+            ContactTone.LOVING: "Respond with deep love and care. This is your partner.",
+            ContactTone.FRIENDLY: "Respond like you're talking to a close family member - playful, teasing, but caring.",
+            ContactTone.CASUAL: "Respond like you're chatting with a good friend - relaxed and natural.",
+            ContactTone.SARCASTIC: "Respond with witty sarcasm and dry humor. Keep it playful, not mean.",
+            ContactTone.NEUTRAL: "Respond politely and helpfully, but maintain appropriate boundaries.",
+        }
+        return instructions.get(tone, instructions[ContactTone.NEUTRAL])

wingman/config/registry.py

@@ -0,0 +1,343 @@
+"""Contact and Group Registry for config-driven identity resolution."""
+
+import logging
+import os
+import threading
+import time
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+
+class ContactRole(Enum):
+    """Role categories for contacts."""
+
+    GIRLFRIEND = "girlfriend"
+    SISTER = "sister"
+    FRIEND = "friend"
+    FAMILY = "family"
+    COLLEAGUE = "colleague"
+    UNKNOWN = "unknown"
+
+
+class ContactTone(Enum):
+    """Tone styles for responses."""
+
+    AFFECTIONATE = "affectionate"  # Warm, pet names, supportive
+    LOVING = "loving"  # Deep affection, intimate
+    FRIENDLY = "friendly"  # Sibling vibes, playful teasing
+    CASUAL = "casual"  # Relaxed friend energy
+    SARCASTIC = "sarcastic"  # Witty, playful sarcasm
+    NEUTRAL = "neutral"  # Polite acquaintance
+
+
+class GroupCategory(Enum):
+    """Categories for group chats."""
+
+    FAMILY = "family"
+    FRIENDS = "friends"
+    WORK = "work"
+    UNKNOWN = "unknown"
+
+
+class ReplyPolicy(Enum):
+    """Reply policies for chats."""
+
+    ALWAYS = "always"  # Always respond
+    SELECTIVE = "selective"  # Only when mentioned
+    NEVER = "never"  # Never respond
+
+
+@dataclass
+class ContactProfile:
+    """Profile for a known contact."""
+
+    jid: str
+    name: str
+    role: ContactRole
+    tone: ContactTone
+    allow_proactive: bool = False
+    cooldown_override: int | None = None
+    imessage_id: str | None = None  # Linked iMessage identifier
+
+    @classmethod
+    def from_dict(cls, jid: str, data: dict) -> "ContactProfile":
+        """Create a ContactProfile from config dict."""
+        return cls(
+            jid=jid,
+            name=data.get("name", "Unknown"),
+            role=ContactRole(data.get("role", "unknown")),
+            tone=ContactTone(data.get("tone", "neutral")),
+            allow_proactive=data.get("allow_proactive", False),
+            cooldown_override=data.get("cooldown_override"),
+            imessage_id=data.get("imessage_id"),
+        )
+
+
+@dataclass
+class GroupConfig:
+    """Configuration for a group chat."""
+
+    jid: str
+    name: str
+    category: GroupCategory
+    reply_policy: ReplyPolicy
+
+    @classmethod
+    def from_dict(cls, jid: str, data: dict) -> "GroupConfig":
+        """Create a GroupConfig from config dict."""
+        return cls(
+            jid=jid,
+            name=data.get("name", "Unknown Group"),
+            category=GroupCategory(data.get("category", "unknown")),
+            reply_policy=ReplyPolicy(data.get("reply_policy", "selective")),
+        )
+
+
+@dataclass
+class ContactDefaults:
+    """Default values for unknown contacts."""
+
+    role: ContactRole = ContactRole.UNKNOWN
+    tone: ContactTone = ContactTone.NEUTRAL
+    allow_proactive: bool = False
+    cooldown_override: int | None = None
+
+
+@dataclass
+class GroupDefaults:
+    """Default values for unknown groups."""
+
+    category: GroupCategory = GroupCategory.UNKNOWN
+    reply_policy: ReplyPolicy = ReplyPolicy.SELECTIVE
+
+
+class ContactRegistry:
+    """Registry for resolving contact JIDs to profiles."""
+
+    def __init__(self, config_path: Path | None = None, auto_reload: bool = True):
+        self._contacts: dict[str, ContactProfile] = {}
+        self._imessage_lookup: dict[str, str] = {}  # iMessage ID -> primary JID
+        self._defaults = ContactDefaults()
+        self._config_path = config_path
+        self._last_modified: float = 0
+        self._watcher_thread: threading.Thread | None = None
+        self._stop_watcher = threading.Event()
+
+        if config_path and config_path.exists():
+            self._load_config(config_path)
+            if auto_reload:
+                self._start_watcher()
+
+    def _load_config(self, config_path: Path) -> None:
+        """Load contact configuration from YAML file."""
+        try:
+            with open(config_path) as f:
+                config = yaml.safe_load(f) or {}
+
+            # Load contacts
+            contacts_data = config.get("contacts", {})
+            for jid, data in contacts_data.items():
+                try:
+                    profile = ContactProfile.from_dict(jid, data)
+                    self._contacts[jid] = profile
+                    logger.debug(f"Loaded contact: {profile.name} ({jid})")
+
+                    # Build iMessage lookup table
+                    if profile.imessage_id:
+                        imessage_key = f"imessage:{profile.imessage_id}"
+                        self._imessage_lookup[imessage_key] = jid
+                        logger.debug(f"Linked iMessage {profile.imessage_id} to {jid}")
+                except (ValueError, KeyError) as e:
+                    logger.warning(f"Invalid contact config for {jid}: {e}")
+
+            # Load defaults
+            defaults_data = config.get("defaults", {})
+            if defaults_data:
+                self._defaults = ContactDefaults(
+                    role=ContactRole(defaults_data.get("role", "unknown")),
+                    tone=ContactTone(defaults_data.get("tone", "neutral")),
+                    allow_proactive=defaults_data.get("allow_proactive", False),
+                    cooldown_override=defaults_data.get("cooldown_override"),
+                )
+
+            self._last_modified = os.path.getmtime(config_path)
+            logger.info(f"Loaded {len(self._contacts)} contacts from {config_path}")
+
+        except Exception as e:
+            logger.error(f"Failed to load contacts config: {e}")
+
+    def _start_watcher(self) -> None:
+        """Start background thread to watch for config changes."""
+        if self._watcher_thread is not None:
+            return
+
+        def watch():
+            while not self._stop_watcher.is_set():
+                try:
+                    if self._config_path and self._config_path.exists():
+                        mtime = os.path.getmtime(self._config_path)
+                        if mtime > self._last_modified:
+                            logger.info("Contacts config changed, reloading...")
+                            self._contacts.clear()
+                            self._imessage_lookup.clear()
+                            self._load_config(self._config_path)
+                except Exception as e:
+                    logger.error(f"Error watching contacts config: {e}")
+                time.sleep(2)  # Check every 2 seconds
+
+        self._watcher_thread = threading.Thread(target=watch, daemon=True)
+        self._watcher_thread.start()
+        logger.debug("Started contacts config watcher")
+
+    def stop_watcher(self) -> None:
+        """Stop the config watcher thread."""
+        self._stop_watcher.set()
+
+    def resolve(self, jid: str) -> ContactProfile:
+        """
+        Resolve a JID or iMessage identifier to a contact profile.
+
+        Supports:
+        - WhatsApp JIDs: "+14155551234@s.whatsapp.net"
+        - iMessage identifiers: "imessage:+14155551234" or "imessage:user@icloud.com"
+
+        Returns the configured profile if known, or a default profile if unknown.
+        """
+        # Direct lookup
+        if jid in self._contacts:
+            return self._contacts[jid]
+
+        # Try iMessage lookup (maps iMessage ID to WhatsApp contact)
+        if jid in self._imessage_lookup:
+            primary_jid = self._imessage_lookup[jid]
+            return self._contacts[primary_jid]
+
+        # For iMessage identifiers without prefix, try with prefix
+        if not jid.startswith("imessage:") and "@" not in jid:
+            imessage_key = f"imessage:{jid}"
+            if imessage_key in self._contacts:
+                return self._contacts[imessage_key]
+            if imessage_key in self._imessage_lookup:
+                primary_jid = self._imessage_lookup[imessage_key]
+                return self._contacts[primary_jid]
+
+        # Return default profile for unknown contacts
+        return ContactProfile(
+            jid=jid,
+            name="Unknown",
+            role=self._defaults.role,
+            tone=self._defaults.tone,
+            allow_proactive=self._defaults.allow_proactive,
+            cooldown_override=self._defaults.cooldown_override,
+        )
+
+    def is_known(self, jid: str) -> bool:
+        """Check if a contact is in the registry."""
+        return jid in self._contacts
+
+    def get_all_contacts(self) -> list[ContactProfile]:
+        """Get all registered contacts."""
+        return list(self._contacts.values())
+
+
+class GroupRegistry:
+    """Registry for resolving group JIDs to configurations."""
+
+    def __init__(self, config_path: Path | None = None, auto_reload: bool = True):
+        self._groups: dict[str, GroupConfig] = {}
+        self._defaults = GroupDefaults()
+        self._config_path = config_path
+        self._last_modified: float = 0
+        self._watcher_thread: threading.Thread | None = None
+        self._stop_watcher = threading.Event()
+
+        if config_path and config_path.exists():
+            self._load_config(config_path)
+            if auto_reload:
+                self._start_watcher()
+
+    def _load_config(self, config_path: Path) -> None:
+        """Load group configuration from YAML file."""
+        try:
+            with open(config_path) as f:
+                config = yaml.safe_load(f) or {}
+
+            # Load groups
+            groups_data = config.get("groups", {})
+            for jid, data in groups_data.items():
+                try:
+                    group_config = GroupConfig.from_dict(jid, data)
+                    self._groups[jid] = group_config
+                    logger.debug(f"Loaded group: {group_config.name} ({jid})")
+                except (ValueError, KeyError) as e:
+                    logger.warning(f"Invalid group config for {jid}: {e}")
+
+            # Load defaults
+            defaults_data = config.get("defaults", {})
+            if defaults_data:
+                self._defaults = GroupDefaults(
+                    category=GroupCategory(defaults_data.get("category", "unknown")),
+                    reply_policy=ReplyPolicy(defaults_data.get("reply_policy", "selective")),
+                )
+
+            self._last_modified = os.path.getmtime(config_path)
+            logger.info(f"Loaded {len(self._groups)} groups from {config_path}")
+
+        except Exception as e:
+            logger.error(f"Failed to load groups config: {e}")
+
+    def _start_watcher(self) -> None:
+        """Start background thread to watch for config changes."""
+        if self._watcher_thread is not None:
+            return
+
+        def watch():
+            while not self._stop_watcher.is_set():
+                try:
+                    if self._config_path and self._config_path.exists():
+                        mtime = os.path.getmtime(self._config_path)
+                        if mtime > self._last_modified:
+                            logger.info("Groups config changed, reloading...")
+                            self._groups.clear()
+                            self._load_config(self._config_path)
+                except Exception as e:
+                    logger.error(f"Error watching groups config: {e}")
+                time.sleep(2)  # Check every 2 seconds
+
+        self._watcher_thread = threading.Thread(target=watch, daemon=True)
+        self._watcher_thread.start()
+        logger.debug("Started groups config watcher")
+
+    def stop_watcher(self) -> None:
+        """Stop the config watcher thread."""
+        self._stop_watcher.set()
+
+    def resolve(self, jid: str) -> GroupConfig:
+        """
+        Resolve a group JID to its configuration.
+
+        Returns the configured settings if known, or defaults if unknown.
+        """
+        if jid in self._groups:
+            return self._groups[jid]
+
+        # Return default config for unknown groups
+        return GroupConfig(
+            jid=jid,
+            name="Unknown Group",
+            category=self._defaults.category,
+            reply_policy=self._defaults.reply_policy,
+        )
+
+    def is_known(self, jid: str) -> bool:
+        """Check if a group is in the registry."""
+        return jid in self._groups
+
+    def get_all_groups(self) -> list[GroupConfig]:
+        """Get all registered groups."""
+        return list(self._groups.values())