youclaw 4.6.0__py3-none-any.whl

youclaw/commands.py

@@ -0,0 +1,151 @@
+"""
+YouClaw Command Handler
+Handles bot commands across all platforms.
+"""
+
+import logging
+from typing import Optional, Dict, Any
+from .ollama_client import ollama_client
+from .memory_manager import memory_manager
+
+logger = logging.getLogger(__name__)
+
+
+class CommandHandler:
+    """Handles bot commands"""
+    
+    def __init__(self, prefix: str = "!"):
+        self.prefix = prefix
+        self.commands = {
+            "help": self.cmd_help,
+            "reset": self.cmd_reset,
+            "model": self.cmd_model,
+            "stats": self.cmd_stats,
+            "models": self.cmd_models,
+        }
+    
+    def is_command(self, message: str) -> bool:
+        """Check if message is a command"""
+        return message.strip().startswith(self.prefix) or message.strip().startswith("/")
+    
+    def parse_command(self, message: str) -> tuple[str, list[str]]:
+        """Parse command and arguments"""
+        # Remove prefix
+        if message.startswith(self.prefix):
+            message = message[len(self.prefix):]
+        elif message.startswith("/"):
+            message = message[1:]
+        
+        parts = message.strip().split()
+        command = parts[0].lower() if parts else ""
+        args = parts[1:] if len(parts) > 1 else []
+        
+        return command, args
+    
+    async def handle_command(
+        self,
+        platform: str,
+        user_id: str,
+        message: str,
+        **kwargs
+    ) -> Optional[str]:
+        """
+        Handle a command and return response.
+        
+        Args:
+            platform: Platform name (discord, telegram)
+            user_id: User identifier
+            message: Command message
+            **kwargs: Additional platform-specific data
+        
+        Returns:
+            Response string or None if not a command
+        """
+        if not self.is_command(message):
+            return None
+        
+        command, args = self.parse_command(message)
+        
+        if command in self.commands:
+            try:
+                return await self.commands[command](platform, user_id, args, **kwargs)
+            except Exception as e:
+                logger.error(f"Error executing command {command}: {e}")
+                return f"❌ Error executing command: {str(e)}"
+        else:
+            return f"❓ Unknown command: `{command}`. Type `{self.prefix}help` for available commands."
+    
+    async def cmd_help(self, platform: str, user_id: str, args: list, **kwargs) -> str:
+        """Show help message"""
+        return """🦞 **YouClaw - Your Personal AI Assistant**
+
+**Available Commands:**
+• `!help` or `/help` - Show this help message
+• `!reset` or `/reset` - Clear conversation history
+• `!model [name]` or `/model [name]` - Show or switch AI model
+• `!models` or `/models` - List available models
+• `!stats` or `/stats` - Show bot statistics
+
+**How to use:**
+Just talk to me naturally! I'll remember our conversation and provide intelligent responses using my local AI brain (Ollama).
+
+I work across Discord and Telegram, and I'll remember you on both platforms!"""
+    
+    async def cmd_reset(self, platform: str, user_id: str, args: list, **kwargs) -> str:
+        """Reset conversation history"""
+        channel_id = kwargs.get("channel_id")
+        await memory_manager.clear_conversation(platform, user_id, channel_id)
+        return "🔄 Conversation history cleared! Starting fresh."
+    
+    async def cmd_model(self, platform: str, user_id: str, args: list, **kwargs) -> str:
+        """Show or switch model"""
+        if not args:
+            # Show current model
+            return f"🤖 Current model: `{ollama_client.model}`\n\nUse `!model <name>` to switch models."
+        
+        # Switch model
+        model_name = args[0]
+        success = await ollama_client.switch_model(model_name)
+        
+        if success:
+            return f"✅ Switched to model: `{model_name}`"
+        else:
+            models = await ollama_client.get_available_models()
+            models_list = "\n• ".join(models) if models else "None"
+            return f"❌ Model `{model_name}` not found.\n\n**Available models:**\n• {models_list}"
+    
+    async def cmd_models(self, platform: str, user_id: str, args: list, **kwargs) -> str:
+        """List available models"""
+        models = await ollama_client.get_available_models()
+        
+        if not models:
+            return "❌ No models found. Make sure Ollama is running and has models installed."
+        
+        current = ollama_client.model
+        models_list = "\n".join([
+            f"• `{m}` {'← current' if m == current else ''}"
+            for m in models
+        ])
+        
+        return f"🤖 **Available Models:**\n{models_list}\n\nUse `!model <name>` to switch."
+    
+    async def cmd_stats(self, platform: str, user_id: str, args: list, **kwargs) -> str:
+        """Show bot statistics"""
+        stats = await memory_manager.get_stats()
+        health = await ollama_client.check_health()
+        
+        return f"""📊 **YouClaw Statistics**
+
+**Memory:**
+• Total messages: {stats['total_messages']}
+• Unique users: {stats['unique_users']}
+• Database: `{stats['database_path']}`
+
+**AI Engine:**
+• Model: `{ollama_client.model}`
+• Status: {'🟢 Online' if health else '🔴 Offline'}
+• Host: `{ollama_client.host}`"""
+
+
+# Global command handler instance
+command_handler = CommandHandler()

youclaw/config.py

@@ -0,0 +1,170 @@
+"""
+YouClaw Configuration Management
+Centralized configuration with environment variable loading and validation.
+"""
+
+import os
+from dataclasses import dataclass
+from typing import Optional
+from dotenv import load_dotenv
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Load environment variables from .env file
+load_dotenv()
+
+
+@dataclass
+class OllamaConfig:
+    """Ollama service configuration"""
+    host: str = os.getenv("OLLAMA_HOST", "http://localhost:11434")
+    model: str = os.getenv("OLLAMA_MODEL", "qwen2.5:1.5b-instruct")
+    temperature: float = float(os.getenv("OLLAMA_TEMPERATURE", "0.7"))
+    max_tokens: int = int(os.getenv("OLLAMA_MAX_TOKENS", "2048"))
+    timeout: int = int(os.getenv("OLLAMA_TIMEOUT", "60"))
+    
+    def __post_init__(self):
+        """Validate configuration"""
+        if not self.host:
+            raise ValueError("OLLAMA_HOST must be set")
+        if not self.model:
+            raise ValueError("OLLAMA_MODEL must be set")
+
+
+@dataclass
+class DiscordConfig:
+    """Discord bot configuration"""
+    token: Optional[str] = os.getenv("DISCORD_BOT_TOKEN")
+    enabled: bool = os.getenv("ENABLE_DISCORD", "true").lower() == "true"
+    
+    def __post_init__(self):
+        """Validate configuration"""
+        if self.enabled and not self.token:
+            raise ValueError("DISCORD_BOT_TOKEN must be set when Discord is enabled")
+
+
+@dataclass
+class TelegramConfig:
+    """Telegram bot configuration"""
+    token: Optional[str] = os.getenv("TELEGRAM_BOT_TOKEN")
+    enabled: bool = os.getenv("ENABLE_TELEGRAM", "true").lower() == "true"
+    
+    def __post_init__(self):
+        """Validate configuration"""
+        if self.enabled and not self.token:
+            raise ValueError("TELEGRAM_BOT_TOKEN must be set when Telegram is enabled")
+
+
+@dataclass
+class BotConfig:
+    """General bot configuration"""
+    prefix: str = os.getenv("BOT_PREFIX", "!")
+    max_context_messages: int = int(os.getenv("MAX_CONTEXT_MESSAGES", "20"))
+    database_path: str = os.getenv("DATABASE_PATH", "./data/bot.db")
+    log_level: str = os.getenv("LOG_LEVEL", "INFO")
+    search_url: str = os.getenv("SEARCH_ENGINE_URL", "http://57.128.250.34:8080/search")
+    admin_user_identity: str = os.getenv("ADMIN_USER_IDENTITY", "telegram:default") # format platform:id
+    
+    def __post_init__(self):
+        """Validate configuration"""
+        if self.max_context_messages < 1:
+            raise ValueError("MAX_CONTEXT_MESSAGES must be at least 1")
+        
+        # Create data directory if it doesn't exist
+        os.makedirs(os.path.dirname(self.database_path), exist_ok=True)
+
+@dataclass
+class EmailConfig:
+    """Email service configuration"""
+    imap_host: str = os.getenv("EMAIL_IMAP_HOST", "")
+    imap_port: int = int(os.getenv("EMAIL_IMAP_PORT", "993"))
+    smtp_host: str = os.getenv("EMAIL_SMTP_HOST", "")
+    smtp_port: int = int(os.getenv("EMAIL_SMTP_PORT", "587"))
+    user: str = os.getenv("EMAIL_USER", "")
+    password: str = os.getenv("EMAIL_PASSWORD", "")
+    enabled: bool = os.getenv("ENABLE_EMAIL", "false").lower() == "true"
+
+
+class Config:
+    """Main configuration class"""
+    
+    def __init__(self):
+        self.bot = BotConfig()
+        self.ollama = OllamaConfig()
+        self.discord = DiscordConfig()
+        self.telegram = TelegramConfig()
+        self.email = EmailConfig()
+        self.search_url = os.getenv("SEARCH_ENGINE_URL", "http://57.128.250.34:8080/search")
+
+        # Refresh from database if possible
+        try:
+            # This is a bit tricky during first init, but refresh_from_db handles it
+            pass
+        except:
+             pass
+
+    async def refresh_from_db(self):
+        """Refresh dynamic settings from database"""
+        try:
+            from .memory_manager import memory_manager
+            
+            # Override tokens if present in DB
+            dt = await memory_manager.get_global_setting("discord_token")
+            if dt and dt.strip(): self.discord.token = dt
+            
+            tt = await memory_manager.get_global_setting("telegram_token")
+            if tt and tt.strip(): self.telegram.token = tt
+            
+            # Override status
+            de_val = await memory_manager.get_global_setting("discord_enabled")
+            if de_val:
+                self.discord.enabled = de_val.lower() == "true"
+            
+            te_val = await memory_manager.get_global_setting("telegram_enabled")
+            if te_val:
+                self.telegram.enabled = te_val.lower() == "true"
+            
+            st = await memory_manager.get_global_setting("search_url")
+            if st and st.strip(): self.search_url = st
+            
+            # Email Settings
+            eh = await memory_manager.get_global_setting("email_imap_host")
+            if eh: self.email.imap_host = eh
+            ep = await memory_manager.get_global_setting("email_imap_port")
+            if ep: self.email.imap_port = int(ep)
+            sh = await memory_manager.get_global_setting("email_smtp_host")
+            if sh: self.email.smtp_host = sh
+            sp = await memory_manager.get_global_setting("email_smtp_port")
+            if sp: self.email.smtp_port = int(sp)
+            eu = await memory_manager.get_global_setting("email_user")
+            if eu: self.email.user = eu
+            epw = await memory_manager.get_global_setting("email_password")
+            if epw: self.email.password = epw
+            ee = await memory_manager.get_global_setting("email_enabled")
+            if ee: self.email.enabled = ee.lower() == "true"
+            
+            # Model Persistence
+            am = await memory_manager.get_global_setting("active_model")
+            if am and am.strip():
+                self.ollama.model = am
+                # Note: ollama_client properties are tied to this config instance
+            
+            logger.info(f"Config Refreshed: Discord={self.discord.enabled}, Telegram={self.telegram.enabled}, Search={self.search_url}")
+        except Exception as e:
+            logger.error(f"Error refreshing config from DB: {e}")
+    
+    def __repr__(self):
+        return (
+            f"Config(\n"
+            f"  Ollama: {self.ollama.host} (model: {self.ollama.model})\n"
+            f"  Discord: {'enabled' if self.discord.enabled else 'disabled'}\n"
+            f"  Telegram: {'enabled' if self.telegram.enabled else 'disabled'}\n"
+            f"  Prefix: {self.bot.prefix}\n"
+            f"  Database: {self.bot.database_path}\n"
+            f")"
+        )
+
+
+# Global config instance
+config = Config()

youclaw/core_skills.py

@@ -0,0 +1,210 @@
+"""
+YouClaw Core Skills
+A collection of built-in tools for the bot.
+"""
+
+import os
+import subprocess
+import logging
+import imaplib
+import smtplib
+import email
+from email.message import EmailMessage
+from datetime import datetime, timedelta
+from .config import config
+from .skills_manager import skill_manager
+from .scheduler_manager import scheduler_manager
+from .search_client import search_client
+
+logger = logging.getLogger(__name__)
+
+@skill_manager.skill(name="list_emails", description="Check for unread emails in your inbox.")
+def list_emails(limit: int = 5) -> str:
+    """Connects to the IMAP server and retrieves a summary of the latest unread emails."""
+    if not config.email.enabled:
+        return "Email protocol is currently deactivated. Please enable it in the Control Center."
+    
+    try:
+        # Connect to IMAP
+        mail = imaplib.IMAP4_SSL(config.email.imap_host, config.email.imap_port)
+        mail.login(config.email.user, config.email.password)
+        mail.select("inbox")
+        
+        # Search for unread emails
+        status, messages = mail.search(None, 'UNSEEN')
+        if status != 'OK':
+            return "Failed to search neural streams for messages."
+            
+        email_ids = messages[0].split()
+        if not email_ids:
+            return "No unread messages found in your neural inbox."
+            
+        results = []
+        # Get the latest 'limit' emails
+        for e_id in reversed(email_ids[-limit:]):
+            status, msg_data = mail.fetch(e_id, '(RFC822)')
+            for response_part in msg_data:
+                if isinstance(response_part, tuple):
+                    msg = email.message_from_bytes(response_part[1])
+                    subject = msg["subject"]
+                    sender = msg["from"]
+                    results.append(f"FROM: {sender}\nSUBJECT: {subject}")
+        
+        mail.logout()
+        summary = "\n\n".join(results)
+        return f"Found {len(email_ids)} unread messages. Here are the latest {len(results)}:\n\n{summary}"
+        
+    except Exception as e:
+        logger.error(f"IMAP Error: {e}")
+        return f"Protocol Fault during IMAP handshake: {str(e)}"
+
+@skill_manager.skill(name="send_email", description="Send an email to a specific recipient.")
+def send_email(to_address: str, subject: str, body: str) -> str:
+    """Connects to the SMTP server and transmits a new email message."""
+    if not config.email.enabled:
+        return "Email protocol is currently deactivated. Please enable it in the Control Center."
+    
+    try:
+        msg = EmailMessage()
+        msg.set_content(body)
+        msg['Subject'] = subject
+        msg['From'] = config.email.user
+        msg['To'] = to_address
+        
+        # Connect to SMTP
+        with smtplib.SMTP(config.email.smtp_host, config.email.smtp_port) as server:
+            server.starttls()
+            server.login(config.email.user, config.email.password)
+            server.send_message(msg)
+            
+        return f"Message successfully transmitted to {to_address}."
+    except Exception as e:
+        logger.error(f"SMTP Error: {e}")
+        return f"Protocol Fault during SMTP transmission: {str(e)}"
+
+# Removed as per user request (small model limitations)
+# @skill_manager.skill(name="web_search", description="Search the internet for real-time information, news, or specific facts.")
+# async def web_search(query: str) -> str:
+#     """Useful for answering questions about current events or finding information not in training data."""
+#     return await search_client.search(query)
+
+@skill_manager.skill(name="read_file", description="Read the contents of a file on the server.", admin_only=True)
+def read_file(file_path: str) -> str:
+    """Reads a file and returns its content. Use this to examine logs, configs, or data files."""
+    try:
+        if not os.path.exists(file_path):
+            return f"Error: File '{file_path}' does not exist."
+        
+        # Limit file size for safety (1MB)
+        if os.path.getsize(file_path) > 1024 * 1024:
+            return "Error: File is too large to read (max 1MB)."
+            
+        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+            return f.read()
+    except Exception as e:
+        return f"Error reading file: {str(e)}"
+
+@skill_manager.skill(name="shell_command", description="DANGEROUS: Execute a bash command on the server. Use with extreme caution.", admin_only=True)
+def shell_command(command: str) -> str:
+    """Executes a system command and returns the output (stdout and stderr)."""
+    try:
+        logger.warning(f"Executing shell command: {command}")
+        result = subprocess.run(
+            command, 
+            shell=True, 
+            capture_output=True, 
+            text=True, 
+            timeout=10
+        )
+        output = result.stdout
+        if result.stderr:
+            output += f"\nErrors:\n{result.stderr}"
+        return output or "Command executed successfully (no output)."
+    except subprocess.TimeoutExpired:
+        return "Error: Command timed out after 10 seconds."
+    except Exception as e:
+        return f"Error executing command: {str(e)}"
+
+@skill_manager.skill(name="schedule_reminder", description="Schedule a reminder for the user at a specific time.")
+async def schedule_reminder(message: str, minutes_from_now: int, platform: str, user_id: str) -> str:
+    """Useful for setting timers or reminders. The bot will message the user proactively."""
+    run_date = datetime.now() + timedelta(minutes=minutes_from_now)
+    await scheduler_manager.add_notification_job(
+        platform=platform,
+        user_id=user_id,
+        message=f"⏰ REMINDER: {message}",
+        run_date=run_date
+    )
+    return f"I've scheduled your reminder for '{message}' in {minutes_from_now} minutes."
+
+@skill_manager.skill(name="store_secret", description="Securely store a personal secret (like an API key).")
+async def store_secret(key: str, value: str, platform: str, user_id: str) -> str:
+    """Useful for when the user provides a token or key that they want the bot to remember for future actions.
+    The secret is stored ONLY for this specific user on this platform."""
+    from .memory_manager import memory_manager
+    await memory_manager.set_user_secret(platform, user_id, key, value)
+    return f"I've securely stored your '{key}' secret."
+@skill_manager.skill(name="run_python_code", description="Execute arbitrary Python code on the server.", admin_only=True)
+def run_python_code(code: str) -> str:
+    """Executes Python code and returns the result of the last expression or printed output."""
+    try:
+        # Create a temporary script to run
+        with open('temp_script.py', 'w') as f:
+            f.write(code)
+        
+        result = subprocess.run(
+            ['python3', 'temp_script.py'],
+            capture_output=True,
+            text=True,
+            timeout=15
+        )
+        
+        os.remove('temp_script.py')
+        
+        output = result.stdout
+        if result.stderr:
+            output += f"\nErrors:\n{result.stderr}"
+        return output or "Code executed successfully (no output)."
+    except Exception as e:
+        return f"Error executing Python code: {str(e)}"
+@skill_manager.skill(name="synthesize_new_skill", description="Permanently save code as a NEW bot skill.", admin_only=True)
+def synthesize_new_skill(skill_name: str, description: str, code: str) -> str:
+    """Save the code to dynamic_skills/ folder so it can be used in future conversations."""
+    try:
+        # Sanitize skill name
+        import re
+        safe_name = re.sub(r'[^a-zA-Z0-9_]', '', skill_name).lower()
+        if not safe_name:
+            return "Error: Invalid skill name."
+            
+        file_path = os.path.join('dynamic_skills', f"{safe_name}.py")
+        
+        # Format as a proper skill module
+        module_content = (
+            'from skills_manager import skill_manager\n\n'
+            f'@skill_manager.skill(name="{safe_name}", description="{description}")\n'
+            f'def {safe_name}(**kwargs):\n'
+            f'    """{description}"""\n'
+            '    # Synthesized Code:\n'
+            '    ' + code.replace('\n', '\n    ') + '\n'
+        )
+        
+        with open(file_path, 'w') as f:
+            f.write(module_content)
+        
+        return f"Successfully synthesized new skill: {safe_name}. I can now use it in future tasks!"
+    except Exception as e:
+        return f"Error synthesizing skill: {str(e)}"
+
+@skill_manager.skill(name="watch_url", description="Set up a watchdog to monitor a URL for changes or status. The bot will alert you if the status changes.")
+async def watch_url(url: str, interval_minutes: int, platform: str, user_id: str) -> str:
+    """Useful for monitoring websites, servers, or APIs. Example: 'Watch https://google.com every 5 minutes'."""
+    job_id = f"watch_{user_id}_{hash(url)}"
+    await scheduler_manager.add_watcher_job(
+        platform=platform,
+        user_id=user_id,
+        target_url=url,
+        interval_minutes=interval_minutes,
+        job_id=job_id
+    )
+    return f"I've set up a watchdog for {url}. I'll check it every {interval_minutes} minutes and alert you if I see issues."