youclaw 4.6.0__py3-none-any.whl

youclaw/discord_handler.py

@@ -0,0 +1,187 @@
+"""
+YouClaw Discord Handler
+Handles Discord-specific message processing and bot interactions.
+"""
+
+import discord
+from discord.ext import commands as discord_commands
+import logging
+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 asyncio
+
+logger = logging.getLogger(__name__)
+
+
+class DiscordHandler:
+    """Handles Discord platform integration"""
+    
+    def __init__(self):
+        # Set up Discord intents
+        intents = discord.Intents.default()
+        intents.message_content = True  # Required to read message content
+        intents.messages = True
+        intents.guilds = True
+        
+        self.bot = discord_commands.Bot(command_prefix=config.bot.prefix, intents=intents)
+        self.setup_events()
+    
+    def setup_events(self):
+        """Set up Discord event handlers"""
+        
+        @self.bot.event
+        async def on_ready():
+            logger.info(f"Discord bot logged in as {self.bot.user}")
+            await self.bot.change_presence(
+                activity=discord.Activity(
+                    type=discord.ActivityType.listening,
+                    name="your messages | !help"
+                )
+            )
+        
+        @self.bot.event
+        async def on_message(message: discord.Message):
+            # Ignore messages from the bot itself
+            if message.author == self.bot.user:
+                return
+            
+            # Ignore messages from other bots
+            if message.author.bot:
+                return
+            
+            # Only respond to DMs or mentions
+            is_dm = isinstance(message.channel, discord.DMChannel)
+            is_mentioned = self.bot.user in message.mentions
+            
+            if not (is_dm or is_mentioned):
+                return
+            
+            # Get user info
+            user_id = str(message.author.id)
+            channel_id = str(message.channel.id) if not is_dm else None
+            content = message.content
+            
+            # Remove mention from content
+            if is_mentioned:
+                content = content.replace(f"<@{self.bot.user.id}>", "").strip()
+            
+            # Show typing indicator
+            async with message.channel.typing():
+                # Check if it's a command
+                command_response = await command_handler.handle_command(
+                    platform="discord",
+                    user_id=user_id,
+                    message=content,
+                    channel_id=channel_id
+                )
+                
+                if command_response:
+                    await self.send_message(message.channel, command_response)
+                    return
+                
+                # Get conversation history
+                history = await memory_manager.get_conversation_history(
+                    platform="discord",
+                    user_id=user_id,
+                    channel_id=channel_id
+                )
+                
+                # Add current message to history
+                await memory_manager.add_message(
+                    platform="discord",
+                    user_id=user_id,
+                    role="user",
+                    content=content,
+                    channel_id=channel_id,
+                    metadata={"username": str(message.author)}
+                )
+                
+                # Build messages for LLM
+                messages = history + [{"role": "user", "content": content}]
+                
+                # Get user profile and onboarding status
+                profile = await memory_manager.get_user_profile(platform="discord", user_id=user_id)
+                
+                # Check global settings
+                search_enabled = (await memory_manager.get_global_setting("search_enabled", "true")).lower() == "true"
+                
+                # Decide if we need to search
+                search_context = None
+                if search_enabled and any(word in content.lower() for word in ['search', 'find', 'who is', 'what is', 'latest', 'news']):
+                     search_results = await search_client.search(content)
+                     search_context = search_results
+
+                # Get AI response with autonomous tool use
+                logger.info(f"Starting Discord reasoning loop for user {user_id}...")
+                
+                try:
+                    # Use chat_with_tools for autonomous behavior
+                    response = await ollama_client.chat_with_tools(
+                        messages=messages,
+                        user_profile=profile,
+                        context={"user_id": user_id, "platform": "discord"}
+                    )
+                    
+                    if response.strip():
+                        await self.send_message(message.channel, response)
+                    else:
+                        await message.channel.send("Hmm, I'm a bit speechless.")
+                    
+                    logger.info(f"Reasoning complete for user {user_id}")
+                    
+                except Exception as e:
+                    logger.error(f"Error during Discord reasoning: {e}")
+                    error_msg = "Oops, I lost my train of thought. Can we try again?"
+                    await message.channel.send(error_msg)
+                    response = error_msg
+                
+                # Simple heuristic to 'complete' onboarding
+                if not profile['onboarding_completed']:
+                     if len(history) > 2:
+                          await memory_manager.update_user_profile(
+                               platform="discord", 
+                               user_id=user_id, 
+                               onboarding_completed=True
+                          )
+                
+                # Save AI response to memory
+                await memory_manager.add_message(
+                    platform="discord",
+                    user_id=user_id,
+                    role="assistant",
+                    content=response,
+                    channel_id=channel_id
+                )
+    
+    async def send_message(self, channel, content: str):
+        """Send a message, handling Discord's 2000 char limit"""
+        if len(content) <= 2000:
+            await channel.send(content)
+        else:
+            # Split into chunks
+            chunks = [content[i:i+2000] for i in range(0, len(content), 2000)]
+            for chunk in chunks:
+                await channel.send(chunk)
+    
+    async def start(self):
+        """Start the Discord bot"""
+        if not config.discord.enabled:
+            logger.info("Discord is disabled in config")
+            return
+        
+        logger.info("Starting Discord bot...")
+        await self.bot.start(config.discord.token)
+    
+    async def stop(self):
+        """Stop the Discord bot"""
+        if self.bot:
+            await self.bot.close()
+            logger.info("Discord bot stopped")
+
+
+# Global Discord handler instance
+discord_handler = DiscordHandler()

youclaw/env_manager.py

@@ -0,0 +1,61 @@
+"""
+YouClaw Environment Manager
+Safely reads and writes to the .env file to allow live configuration updates.
+"""
+
+import os
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+class EnvManager:
+    """Manages reading and writing to the .env file"""
+    
+    def __init__(self, env_path: str = ".env"):
+        self.env_path = Path(env_path)
+    
+    def get_all(self) -> dict:
+        """Read all environment variables from the file"""
+        if not self.env_path.exists():
+            return {}
+            
+        env_vars = {}
+        with open(self.env_path, 'r') as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith('#') or '=' not in line:
+                    continue
+                key, val = line.split('=', 1)
+                env_vars[key.strip()] = val.strip()
+        return env_vars
+        
+    def set_key(self, key: str, value: str):
+        """Update or add a key-value pair in the .env file"""
+        lines = []
+        found = False
+        
+        if self.env_path.exists():
+            with open(self.env_path, 'r') as f:
+                lines = f.readlines()
+                
+        for i, line in enumerate(lines):
+            line_strip = line.strip()
+            if line_strip.startswith(f"{key}="):
+                lines[i] = f"{key}={value}\n"
+                found = True
+                break
+                
+        if not found:
+            # Add with a newline if file is not empty and doesn't end with one
+            if lines and not lines[-1].endswith('\n'):
+                lines[-1] += '\n'
+            lines.append(f"{key}={value}\n")
+            
+        with open(self.env_path, 'w') as f:
+            f.writelines(lines)
+            
+        logger.info(f"Updated .env: {key}=***")
+
+# Global instance
+env_manager = EnvManager()

youclaw/main.py

@@ -0,0 +1,273 @@
+"""
+YouClaw CLI - Command Line Interface
+Provides commands for installation, health checks, and management.
+"""
+
+import sys
+import subprocess
+import os
+import asyncio
+import argparse
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent))
+
+
+class YouClawCLI:
+    """YouClaw command line interface"""
+    
+    def __init__(self):
+        self.project_dir = Path(__file__).parent
+    
+    def cmd_install(self, args):
+        """Run installation script"""
+        print("🦞 Running YouClaw installation...")
+        install_script = self.project_dir / "install.sh"
+        
+        if not install_script.exists():
+            print("❌ install.sh not found!")
+            return 1
+        
+        result = subprocess.run(["bash", str(install_script)])
+        return result.returncode
+    
+    def cmd_check(self, args):
+        """Run health checks"""
+        print("🦞 YouClaw Health Check")
+        print("=" * 50)
+        
+        # Check Python version
+        print("\n📦 Python Version:")
+        python_version = sys.version.split()[0]
+        print(f"   {python_version}", end="")
+        if sys.version_info >= (3, 10):
+            print(" ✅")
+        else:
+            print(" ❌ (Need 3.10+)")
+        
+        # Check Ollama
+        print("\n🤖 Ollama:")
+        try:
+            result = subprocess.run(
+                ["curl", "-s", "http://localhost:11434/api/tags"],
+                capture_output=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                print("   Connected ✅")
+                # Parse models
+                import json
+                try:
+                    data = json.loads(result.stdout)
+                    models = [m["name"] for m in data.get("models", [])]
+                    print(f"   Models: {', '.join(models) if models else 'None'}")
+                except:
+                    pass
+            else:
+                print("   Not running ❌")
+        except Exception as e:
+            print(f"   Error: {e} ❌")
+        
+        # Check virtual environment
+        print("\n🐍 Virtual Environment:")
+        venv_path = self.project_dir / "venv"
+        if venv_path.exists():
+            print(f"   {venv_path} ✅")
+        else:
+            print("   Not found ❌")
+        
+        # Check .env file
+        print("\n⚙️  Configuration:")
+        env_path = self.project_dir / ".env"
+        if env_path.exists():
+            print("   .env file exists ✅")
+            # Check for tokens
+            with open(env_path) as f:
+                content = f.read()
+                has_discord = "DISCORD_BOT_TOKEN=" in content and "your_discord" not in content
+                has_telegram = "TELEGRAM_BOT_TOKEN=" in content and "your_telegram" not in content
+                
+                if has_discord:
+                    print("   Discord token configured ✅")
+                else:
+                    print("   Discord token not set ⚠️")
+                
+                if has_telegram:
+                    print("   Telegram token configured ✅")
+                else:
+                    print("   Telegram token not set ⚠️")
+        else:
+            print("   .env file missing ❌")
+        
+        # Check database
+        print("\n💾 Database:")
+        db_path = self.project_dir / "data" / "bot.db"
+        if db_path.exists():
+            size = db_path.stat().st_size
+            print(f"   {db_path} ({size} bytes) ✅")
+        else:
+            print("   Not created yet (will be created on first run)")
+        
+        # Check systemd service
+        print("\n🔧 Systemd Service:")
+        try:
+            result = subprocess.run(
+                ["systemctl", "--user", "is-active", "youclaw"],
+                capture_output=True,
+                text=True
+            )
+            status = result.stdout.strip()
+            if status == "active":
+                print("   Running ✅")
+            elif status == "inactive":
+                print("   Stopped ⚠️")
+            else:
+                print(f"   Status: {status}")
+        except Exception as e:
+            print(f"   Not installed ⚠️")
+        
+        print("\n" + "=" * 50)
+        return 0
+    
+    def cmd_status(self, args):
+        """Show service status"""
+        print("🦞 YouClaw Status\n")
+        result = subprocess.run(
+            ["systemctl", "--user", "status", "youclaw"],
+            capture_output=False
+        )
+        return result.returncode
+    
+    def cmd_logs(self, args):
+        """View logs"""
+        print("🦞 YouClaw Logs (Ctrl+C to exit)\n")
+        
+        cmd = ["journalctl", "--user", "-u", "youclaw"]
+        
+        if args.follow:
+            cmd.append("-f")
+        
+        if args.lines:
+            cmd.extend(["-n", str(args.lines)])
+        
+        result = subprocess.run(cmd)
+        return result.returncode
+    
+    def cmd_start(self, args):
+        """Start YouClaw service"""
+        print("🦞 Starting YouClaw...")
+        result = subprocess.run(["systemctl", "--user", "start", "youclaw"])
+        if result.returncode == 0:
+            print("✅ YouClaw started")
+        return result.returncode
+    
+    def cmd_stop(self, args):
+        """Stop YouClaw service"""
+        print("🦞 Stopping YouClaw...")
+        result = subprocess.run(["systemctl", "--user", "stop", "youclaw"])
+        if result.returncode == 0:
+            print("✅ YouClaw stopped")
+        return result.returncode
+    
+    def cmd_restart(self, args):
+        """Restart YouClaw service"""
+        print("🦞 Restarting YouClaw...")
+        result = subprocess.run(["systemctl", "--user", "restart", "youclaw"])
+        if result.returncode == 0:
+            print("✅ YouClaw restarted")
+        return result.returncode
+    
+    def cmd_dashboard(self, args):
+        """Start web dashboard"""
+        print("🦞 Starting YouClaw Dashboard...")
+        print("   Dashboard will be available at http://localhost:8080")
+        print("   Press Ctrl+C to stop\n")
+        
+        # Import and run dashboard
+        try:
+            from dashboard import run_dashboard
+            asyncio.run(run_dashboard(port=args.port))
+        except ImportError as e:
+            print(f"❌ Dashboard module not found. Make sure dashboard.py exists. Error: {e}")
+            return 1
+        except KeyboardInterrupt:
+            print("\n👋 Dashboard stopped")
+            return 0
+    
+    def run(self):
+        """Main CLI entry point"""
+        parser = argparse.ArgumentParser(
+            description="YouClaw - Your Personal AI Assistant",
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            epilog="""
+Examples:
+  youclaw install          # Run installation
+  youclaw check            # Health check
+  youclaw start            # Start service
+  youclaw logs -f          # Follow logs
+  youclaw dashboard        # Start web dashboard
+            """
+        )
+        
+        subparsers = parser.add_subparsers(dest="command", help="Available commands")
+        
+        # Install command
+        subparsers.add_parser("install", help="Run installation script")
+        
+        # Check command
+        subparsers.add_parser("check", help="Run health checks")
+        
+        # Status command
+        subparsers.add_parser("status", help="Show service status")
+        
+        # Logs command
+        logs_parser = subparsers.add_parser("logs", help="View logs")
+        logs_parser.add_argument("-f", "--follow", action="store_true", help="Follow log output")
+        logs_parser.add_argument("-n", "--lines", type=int, default=50, help="Number of lines to show")
+        
+        # Start command
+        subparsers.add_parser("start", help="Start YouClaw service")
+        
+        # Stop command
+        subparsers.add_parser("stop", help="Stop YouClaw service")
+        
+        # Restart command
+        subparsers.add_parser("restart", help="Restart YouClaw service")
+        
+        # Dashboard command
+        dashboard_parser = subparsers.add_parser("dashboard", help="Start web dashboard")
+        dashboard_parser.add_argument("-p", "--port", type=int, default=8080, help="Dashboard port")
+        
+        args = parser.parse_args()
+        
+        if not args.command:
+            parser.print_help()
+            return 0
+        
+        # Execute command
+        command_map = {
+            "install": self.cmd_install,
+            "check": self.cmd_check,
+            "status": self.cmd_status,
+            "logs": self.cmd_logs,
+            "start": self.cmd_start,
+            "stop": self.cmd_stop,
+            "restart": self.cmd_restart,
+            "dashboard": self.cmd_dashboard,
+        }
+        
+        if args.command in command_map:
+            return command_map[args.command](args)
+        else:
+            print(f"Unknown command: {args.command}")
+            return 1
+
+
+def main():
+    cli = YouClawCLI()
+    sys.exit(cli.run())
+
+
+if __name__ == "__main__":
+    main()