youclaw 4.6.0__py3-none-any.whl

youclaw/scheduler_manager.py

@@ -0,0 +1,226 @@
+"""
+YouClaw Scheduler Manager
+Handles background tasks, heartbeats, and proactive notifications.
+"""
+
+import logging
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
+from typing import Dict, Any, Callable, Optional
+from datetime import datetime
+import asyncio
+
+logger = logging.getLogger(__name__)
+
+class SchedulerManager:
+    """Manages proactive bot tasks and cron jobs"""
+    
+    def __init__(self):
+        self.scheduler = AsyncIOScheduler()
+        self.bot_instance = None
+    
+    def initialize(self, bot_instance, db_path: str):
+        """Initialize the scheduler with persistence"""
+        self.bot_instance = bot_instance
+        
+        # Configure job store
+        job_stores = {
+            'default': SQLAlchemyJobStore(url=f'sqlite:///{db_path}')
+        }
+        
+        self.scheduler.configure(jobstores=job_stores)
+        self.scheduler.start()
+        logger.info("Scheduler initialized and started")
+
+    async def add_notification_job(
+        self, 
+        platform: str, 
+        user_id: str, 
+        message: str, 
+        run_date: datetime,
+        job_id: Optional[str] = None
+    ):
+        """Schedule a one-time notification message"""
+        self.scheduler.add_job(
+            self.send_notification,
+            'date',
+            run_date=run_date,
+            args=[platform, user_id, message],
+            id=job_id,
+            replace_existing=True
+        )
+        logger.info(f"Scheduled notification for {user_id} on {platform} at {run_date}")
+
+    async def add_cron_job(
+        self,
+        platform: str,
+        user_id: str,
+        message_func: Callable,
+        cron_expression: str,
+        job_id: str
+    ):
+        """Schedule a recurring tasks using cron expression"""
+        # message_func should be an async function that returns a string to send
+        self.scheduler.add_job(
+            self.run_cron_task,
+            'cron',
+            args=[platform, user_id, message_func],
+            id=job_id,
+            replace_existing=True,
+            **self._parse_cron(cron_expression)
+        )
+        logger.info(f"Scheduled cron job {job_id} for {user_id}")
+
+    def _parse_cron(self, expr: str) -> Dict:
+        """Simple parser for cron expressions (placeholder for robust parser)"""
+        # For now, expect a simple format or use default
+        # Format: "minute hour day month day_of_week"
+        parts = expr.split()
+        if len(parts) == 5:
+            return {
+                'minute': parts[0],
+                'hour': parts[1],
+                'day': parts[2],
+                'month': parts[3],
+                'day_of_week': parts[4]
+            }
+        return {'hour': 8} # Default 8 AM daily
+
+    async def send_notification(self, platform: str, user_id: str, message: str):
+        """Actual delivery of the message via the bot handlers"""
+        await send_notification_task(platform, user_id, message)
+
+    async def add_ai_cron_job(self, platform: str, user_id: str, prompt: str, cron_expr: str, job_id: str):
+        """Schedule a recurring AI reasoning task"""
+        self.scheduler.add_job(
+            run_ai_job_task,
+            'cron',
+            args=[platform, user_id, prompt],
+            id=job_id,
+            replace_existing=True,
+            **self._parse_cron(cron_expr)
+        )
+        logger.info(f"Scheduled AI Pulse job {job_id} for {user_id}: {prompt[:30]}...")
+
+    async def add_watcher_job(self, platform: str, user_id: str, target_url: str, interval_minutes: int, job_id: str):
+        """Schedule a background URL monitoring task"""
+        self.scheduler.add_job(
+            run_watcher_task,
+            'interval',
+            minutes=interval_minutes,
+            args=[platform, user_id, target_url],
+            id=job_id,
+            replace_existing=True
+        )
+        logger.info(f"Scheduled Watcher job {job_id} for {user_id}: {target_url}")
+
+# --- Top-Level Job Tasks (Moved outside class for serialization) ---
+
+async def send_notification_task(platform: str, user_id: str, message: str):
+    """Actual delivery of the message via the bot handlers or history"""
+    from .memory_manager import memory_manager
+    
+    try:
+        if platform == "telegram":
+            from .telegram_handler import telegram_handler
+            if telegram_handler.app:
+                await telegram_handler.app.bot.send_message(chat_id=user_id, text=message)
+            else:
+                logger.error("Telegram App not initialized")
+        elif platform == "discord":
+            from .discord_handler import discord_handler
+            if discord_handler.bot:
+                user = await discord_handler.bot.fetch_user(int(user_id))
+                if user:
+                    await user.send(message)
+                else:
+                    logger.error(f"Discord user {user_id} not found")
+        if platform == "dashboard" or True: # Always save to DB for history
+            await memory_manager.add_message(
+                platform=platform,
+                user_id=user_id,
+                role="assistant",
+                content=message,
+                metadata={"source": "scheduler"}
+            )
+        logger.info(f"Proactive message sent to {user_id} on {platform}")
+    except Exception as e:
+        logger.error(f"Failed to send proactive message: {e}")
+
+async def run_cron_task_worker(platform: str, user_id: str, task_func: Callable):
+    """Run a recurring task and send its output"""
+    try:
+        message = await task_func()
+        if message:
+            await send_notification_task(platform, user_id, message)
+    except Exception as e:
+        logger.error(f"Error in cron task execution: {e}")
+
+async def run_ai_job_task(platform: str, user_id: str, prompt: str):
+    """Executes a full AI reasoning loop and sends the result to the user"""
+    from .memory_manager import memory_manager
+    from .ollama_client import ollama_client
+    from datetime import datetime
+    
+    logger.info(f"Running AI Cron Job for {user_id} on {platform}: {prompt[:50]}")
+    
+    # Fetch recent history to avoid repetition
+    history = await memory_manager.get_conversation_history(platform, user_id, limit=5)
+    
+    # Build context for the AI
+    context = {
+        "platform": platform,
+        "user_id": user_id,
+        "current_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    }
+    
+    # Enhance prompt with variation instructions
+    enhanced_prompt = (
+        f"USER REQUEST: {prompt}\n\n"
+        f"CRITICAL: Do not repeat yourself. If you see in the history that you already said something, "
+        f"try a completely different approach or topic. Be creative!\n"
+        f"Current system time: {context['current_time']}"
+    )
+    
+    try:
+        # Trigger full reasoning loop with history
+        response = await ollama_client.chat_with_tools(
+            messages=history + [{"role": "user", "content": enhanced_prompt}],
+            context=context
+        )
+        
+        if response:
+            logger.info(f"AI Cron Job for {user_id} produced response (length: {len(response)}). Sending...")
+            await send_notification_task(platform, user_id, f"### ⚡ **Cron Job Update**\n\n{response}")
+            logger.info(f"AI Cron Job for {user_id} delivered.")
+        else:
+            logger.warning(f"AI Cron Job for {user_id} produced empty response.")
+    except Exception as e:
+        logger.error(f"Error in AI Cron Job execution: {e}", exc_info=True)
+
+async def run_watcher_task(platform: str, user_id: str, target_url: str):
+    """Monitors a URL and notifies the user of status changes"""
+    import aiohttp
+    
+    logger.info(f"Running Watcher for {user_id} on {platform}: {target_url}")
+    
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(target_url, timeout=10) as response:
+                status = response.status
+                if status != 200:
+                    await send_notification_task(
+                        platform, 
+                        user_id, 
+                        f"⚠️ **Watchdog Alert!**\n\nTarget `{target_url}` is reporting status: `{status}`."
+                    )
+    except Exception as e:
+        logger.error(f"Watcher failed for {target_url}: {e}")
+        await send_notification_task(
+            platform, 
+            user_id, 
+            f"🚨 **Watchdog Failure!**\n\nI couldn't reach `{target_url}`. Error: `{str(e)}`"
+        )
+
+# Global scheduler instance
+scheduler_manager = SchedulerManager()

youclaw/search_client.py

@@ -0,0 +1,66 @@
+import aiohttp
+import logging
+import asyncio
+from typing import List, Dict, Optional
+from bs4 import BeautifulSoup
+from .config import config
+
+logger = logging.getLogger(__name__)
+
+class SearchClient:
+    """Client for performing searches via the self-hosted SearXNG engine"""
+    
+    def __init__(self):
+        self.headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+        }
+
+    async def search(self, query: str) -> str:
+        """
+        Perform a search on SearXNG and return a synthesized summary of findings.
+        """
+        url = config.search_url
+        logger.info(f"🛰️ Neural Search Initiated on {url}: {query}")
+        
+        try:
+            async with aiohttp.ClientSession(headers=self.headers) as session:
+                async with session.get(url, params={"q": query}) as response:
+                    if response.status != 200:
+                        logger.error(f"Search engine returned status {response.status}")
+                        return f"Search engine offline (Status {response.status})"
+                    
+                    html = await response.text()
+                    soup = BeautifulSoup(html, 'html.parser')
+                    
+                    results = []
+                    # SearXNG default theme (simple) result container
+                    articles = soup.select('article.result') or soup.select('.result')
+                    
+                    for i, article in enumerate(articles[:4]):
+                        title_tag = article.select_one('h3 a, .title a')
+                        snippet_tag = article.select_one('.content, .snippet')
+                        
+                        if title_tag:
+                            title = title_tag.get_text(strip=True)
+                            link = title_tag.get('href', '')
+                            snippet = snippet_tag.get_text(strip=True) if snippet_tag else "No details available."
+                            
+                            # Clean up links (SearXNG sometimes wraps them)
+                            if link.startswith('/'):
+                                link = f"{url.split('/search')[0]}{link}"
+                                
+                            results.append(f"SOURCE [{i+1}]: {title}\nURL: {link}\nSUMMARY: {snippet}")
+                    
+                    if not results:
+                        logger.warning("Search returned 0 results.")
+                        return "No real-time data found in the neural streams."
+                    
+                    logger.info(f"✅ Search complete. Found {len(results)} sources.")
+                    return "\n\n".join(results)
+                    
+        except Exception as e:
+            logger.error(f"Search Execution Fault: {e}")
+            return f"Neural Search Error: {str(e)}"
+
+# Global search client instance
+search_client = SearchClient()

youclaw/skills_manager.py

@@ -0,0 +1,127 @@
+"""
+YouClaw Skill Manager
+A system to register and execute bot capabilities (skills).
+"""
+
+import logging
+import inspect
+import functools
+import json
+import os
+import importlib.util
+from typing import Dict, Any, Callable, List, Optional
+
+logger = logging.getLogger(__name__)
+
+class SkillManager:
+    """Manages bot skills and tool registration"""
+    
+    def __init__(self):
+        self.skills: Dict[str, Dict[str, Any]] = {}
+        self.dynamic_dir = "dynamic_skills"
+        if not os.path.exists(self.dynamic_dir):
+            os.makedirs(self.dynamic_dir)
+    
+    def skill(self, name: str = None, description: str = None, admin_only: bool = False):
+        """
+        Decorator to register a function as a skill.
+        
+        Args:
+            name: Optional custom name for the skill (defaults to function name)
+            description: Optional description (defaults to function docstring)
+        """
+        def decorator(func: Callable):
+            skill_name = name or func.__name__
+            skill_description = description or (func.__doc__.strip() if func.__doc__ else "No description available")
+            
+            # Extract parameters from signature
+            sig = inspect.signature(func)
+            parameters = {}
+            for param_name, param in sig.parameters.items():
+                parameters[param_name] = {
+                    "type": str(param.annotation) if param.annotation != inspect.Parameter.empty else "string",
+                    "default": param.default if param.default != inspect.Parameter.empty else None,
+                    "required": param.default == inspect.Parameter.empty
+                }
+            
+            self.skills[skill_name] = {
+                "name": skill_name,
+                "description": skill_description,
+                "func": func,
+                "parameters": parameters,
+                "is_async": inspect.iscoroutinefunction(func),
+                "admin_only": admin_only # Added admin_only flag
+            }
+            
+            logger.info(f"registered skill: {skill_name} (admin_only: {admin_only})")
+            
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)
+            return wrapper
+            
+        return decorator
+
+    async def get_skills_doc(self) -> str:
+        """Get tool definitions as a string for LLM prompting"""
+        tools_list = []
+        for name, info in self.skills.items():
+            params_str = ", ".join([f"{k} ({v['type']}{', required' if v['required'] else ''})" for k, v in info['parameters'].items()])
+            tools_list.append(f"- {name}: {info['description']}\n  Params: {params_str}")
+        
+        return "\n".join(tools_list)
+
+    def get_tool_definitions(self) -> str:
+        # Legacy support
+        return self.get_skills_doc()
+
+    async def execute_skill(self, name: str, arguments: Dict[str, Any]) -> Any:
+        """Execute a registered skill by name"""
+        if name not in self.skills:
+            return f"Error: Skill '{name}' not found"
+        
+        skill = self.skills[name]
+        
+        # Security: Admin-only skill gating
+        if skill.get('admin_only'):
+            platform = arguments.get('platform')
+            user_id = arguments.get('user_id')
+            
+            # For now, we'll use a simple check. We could also check the DB users table.
+            from .config import config
+            admin_id = config.bot.admin_user_identity # e.g. "telegram:123456"
+            current_id = f"{platform}:{user_id}"
+            
+            if current_id != admin_id:
+                logger.warning(f"🛑 Security Alert: Unauthorized access attempt to '{name}' by {current_id}")
+                return f"Permission Denied: Skill '{name}' is reserved for the bot administrator."
+
+        try:
+            logger.info(f"Executing skill '{name}' with args: {arguments}")
+            if skill['is_async']:
+                result = await skill['func'](**arguments)
+            else:
+                result = skill['func'](**arguments)
+            return result
+        except Exception as e:
+            logger.error(f"Error executing skill '{name}': {e}", exc_info=True)
+            return f"Error: {str(e)}"
+
+    def load_dynamic_skills(self):
+        """Scan dynamic_skills folder and import them"""
+        logger.info(f"Scanning for dynamic skills in {self.dynamic_dir}...")
+        for filename in os.listdir(self.dynamic_dir):
+            if filename.endswith(".py") and not filename.startswith("__"):
+                skill_name = filename[:-3]
+                path = os.path.join(self.dynamic_dir, filename)
+                
+                try:
+                    spec = importlib.util.spec_from_file_location(skill_name, path)
+                    module = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(module)
+                    logger.info(f"Loaded dynamic skill: {skill_name}")
+                except Exception as e:
+                    logger.error(f"Failed to load dynamic skill {skill_name}: {e}")
+
+# Global skill manager instance
+skill_manager = SkillManager()

youclaw/telegram_handler.py

@@ -0,0 +1,181 @@
+"""
+YouClaw Telegram Handler
+Handles Telegram-specific message processing and bot interactions.
+"""
+
+from telegram import Update
+from telegram.ext import Application, MessageHandler, filters, ContextTypes
+import logging
+import asyncio
+from typing import Optional
+from .config import config
+from .ollama_client import ollama_client
+from .memory_manager import memory_manager
+from .search_client import search_client
+from .commands import command_handler
+import base64
+import io
+
+logger = logging.getLogger(__name__)
+
+
+class TelegramHandler:
+    """Handles Telegram platform integration"""
+    
+    def __init__(self):
+        self.app: Optional[Application] = None
+    
+    async def handle_message(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """Handle incoming Telegram messages"""
+        if not update.message or not update.message.text:
+            return
+        
+        # Get user info
+        user_id = str(update.effective_user.id)
+        chat_id = str(update.effective_chat.id)
+        content = update.message.text
+        username = update.effective_user.username or update.effective_user.first_name
+        
+        # Send typing action
+        await update.message.chat.send_action("typing")
+        
+        # Check if it's a command
+        command_response = await command_handler.handle_command(
+            platform="telegram",
+            user_id=user_id,
+            message=content,
+            channel_id=chat_id
+        )
+        
+        if command_response:
+            await self.send_message(update, command_response)
+            return
+        
+        # Get user profile and onboarding status
+        profile = await memory_manager.get_user_profile(platform="telegram", user_id=user_id)
+        
+        # Get conversation history
+        history = await memory_manager.get_conversation_history(
+            platform="telegram",
+            user_id=user_id,
+            channel_id=chat_id
+        )
+        
+        # Add current message to history
+        await memory_manager.add_message(
+            platform="telegram",
+            user_id=user_id,
+            role="user",
+            content=content,
+            channel_id=chat_id,
+            metadata={"username": username}
+        )
+        
+        # Build messages for LLM
+        messages = history + [{"role": "user", "content": content}]
+        
+        # Get AI response
+        logger.info(f"Starting generic chat for user {user_id}...")
+        
+        try:
+            # Use autonomous reasoning loop with tools (Reminders, etc.)
+            response = await ollama_client.chat_with_tools(
+                messages=messages,
+                user_profile=profile,
+                context={"platform": "telegram", "user_id": user_id}
+            )
+            
+            if response and response.strip():
+                await self.send_message(update, response)
+            else:
+                await update.message.reply_text("Hmm, I'm not sure what to say.")
+            
+            logger.info(f"Chat complete for user {user_id}")
+            
+        except Exception as e:
+            logger.error(f"Error during reasoning: {e}")
+            error_msg = "I'm sorry, I hit a snag while thinking. Can you try again?"
+            await update.message.reply_text(error_msg)
+            response = error_msg
+        
+        # Simple heuristic to 'complete' onboarding if they gave personal info
+        if not profile['onboarding_completed']:
+             if len(history) > 2:
+                  await memory_manager.update_user_profile(
+                       platform="telegram", 
+                       user_id=user_id, 
+                       onboarding_completed=True
+                  )
+        
+        # Save AI response to memory
+        await memory_manager.add_message(
+            platform="telegram",
+            user_id=user_id,
+            role="assistant",
+            content=response,
+            channel_id=chat_id
+        )
+    
+    async def send_message(self, update: Update, content: str):
+        """Send a message, handling Telegram's 4096 char limit"""
+        if len(content) <= 4096:
+            await update.message.reply_text(content)
+        else:
+            # Split into chunks
+            chunks = [content[i:i+4096] for i in range(0, len(content), 4096)]
+            for chunk in chunks:
+                await update.message.reply_text(chunk)
+    
+    async def start(self):
+        """Start the Telegram bot"""
+        if not config.telegram.enabled:
+            logger.info("Telegram is disabled in config")
+            return
+        
+        logger.info("Starting Telegram bot...")
+        
+        # Create application
+        self.app = Application.builder().token(config.telegram.token).build()
+        
+        # Add message handler
+        self.app.add_handler(
+            MessageHandler(filters.TEXT & ~filters.COMMAND, self.handle_message)
+        )
+        
+        # Add command handler for /start
+        async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
+            await update.message.reply_text(
+                "🦞 **YouClaw - Your Personal AI Assistant**\n\n"
+                "Hello! I'm YouClaw, powered by local AI (Ollama).\n\n"
+                "Just send me a message and I'll respond intelligently. "
+                "I remember our conversations!\n\n"
+                "Type /help to see available commands."
+            )
+        
+        from telegram.ext import CommandHandler
+        self.app.add_handler(CommandHandler("start", start_command))
+        
+        # Start polling
+        await self.app.initialize()
+        await self.app.start()
+        await self.app.updater.start_polling()
+        
+        logger.info("Telegram bot started")
+        
+        # Keep alive until cancelled
+        try:
+            await asyncio.Event().wait()
+        except asyncio.CancelledError:
+            logger.info("Telegram handler task cancelled")
+    
+    async def stop(self):
+        """Stop the Telegram bot"""
+        if self.app:
+            await self.app.updater.stop()
+            await self.app.stop()
+            await self.app.shutdown()
+            logger.info("Telegram bot stopped")
+
+
+# Global Telegram handler instance
+telegram_handler = TelegramHandler()

youclaw/vector_manager.py

@@ -0,0 +1,94 @@
+"""
+YouClaw Vector Manager
+Handles semantic search and embedding storage for long-term memory.
+"""
+
+import logging
+import json
+import numpy as np
+from typing import List, Dict, Any, Optional
+import aiosqlite
+import base64
+from ollama_client import ollama_client
+
+logger = logging.getLogger(__name__)
+
+class VectorManager:
+    """Manages semantic memory using vector embeddings"""
+    
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        self.db: Optional[aiosqlite.Connection] = None
+
+    async def initialize(self):
+        """Initialize the vector database table"""
+        self.db = await aiosqlite.connect(self.db_path)
+        await self.db.execute("""
+            CREATE TABLE IF NOT EXISTS vector_memory (
+                message_id INTEGER PRIMARY KEY,
+                embedding BLOB NOT NULL,
+                FOREIGN KEY (message_id) REFERENCES conversations (id)
+            )
+        """)
+        await self.db.commit()
+        logger.info("Vector manager initialized")
+
+    @staticmethod
+    def _encode_vector(vec: List[float]) -> bytes:
+        """Encode list of floats to binary for storage"""
+        return np.array(vec, dtype=np.float32).tobytes()
+
+    @staticmethod
+    def _decode_vector(bin_vec: bytes) -> np.ndarray:
+        """Decode binary back to numpy array"""
+        return np.frombuffer(bin_vec, dtype=np.float32)
+
+    async def save_embedding(self, message_id: int, text: str):
+        """Generate and save embedding for a message"""
+        embedding = await ollama_client.get_embeddings(text)
+        if not embedding:
+            logger.warning(f"Failed to generate embedding for message {message_id}")
+            return
+
+        bin_vec = self._encode_vector(embedding)
+        await self.db.execute(
+            "INSERT OR REPLACE INTO vector_memory (message_id, embedding) VALUES (?, ?)",
+            (message_id, bin_vec)
+        )
+        await self.db.commit()
+
+    async def search_semantic(self, query: str, limit: int = 5) -> List[Dict[str, Any]]:
+        """Search for semantically similar messages"""
+        query_vec = await ollama_client.get_embeddings(query)
+        if not query_vec:
+            return []
+
+        query_np = np.array(query_vec, dtype=np.float32)
+        
+        # This is a brute-force search (fine for small local DBs)
+        # For larger DBs, we'd use HNSW or Faiss
+        results = []
+        async with self.db.execute("""
+            SELECT vm.message_id, vm.embedding, c.content, c.role, c.timestamp 
+            FROM vector_memory vm
+            JOIN conversations c ON vm.message_id = c.id
+        """) as cursor:
+            async for msg_id, bin_vec, content, role, ts in cursor:
+                msg_vec = self._decode_vector(bin_vec)
+                
+                # Cosine similarity
+                similarity = np.dot(query_np, msg_vec) / (np.linalg.norm(query_np) * np.linalg.norm(msg_vec))
+                
+                results.append({
+                    "id": msg_id,
+                    "content": content,
+                    "role": role,
+                    "timestamp": ts,
+                    "similarity": float(similarity)
+                })
+
+        # Sort by similarity and return top N
+        results.sort(key=lambda x: x['similarity'], reverse=True)
+        return results[:limit]
+
+# The instance will be managed by memory_manager to avoid circular imports