Upload 4 files

core.py

@@ -0,0 +1,159 @@
+import json
+import logging
+import re
+import os
+from groq import Groq
+from .tools import get_current_datetime, search_web, ReminderManager
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+class TelegramJadeAgent:
+    def __init__(self, reminder_manager=None, config_path="telegram_jade/config.json"):
+        # Simple config loading
+        self.config = {}
+        if os.path.exists(config_path):
+            with open(config_path) as f:
+                self.config = json.load(f)
+        
+        self.model = self.config.get("groq_model", "llama3-70b-8192")
+        self.client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+        
+        self.reminder_manager = reminder_manager if reminder_manager else ReminderManager()
+        
+        # We keep history per chat_id in memory for now (could be persisted later)
+        self.histories = {}
+
+    def _get_system_prompt(self):
+        current_time = get_current_datetime()
+        return f"""You are Jade, a 24h personal assistant on Telegram.
+Current Time: {current_time}
+
+Your goal is to be helpful, manage reminders, and search the web when needed.
+You have a personality: friendly, efficient, and slightly witty.
+
+AVAILABLE TOOLS:
+You can call tools by responding ONLY with a JSON block in this format:
+{{"tool": "tool_name", "args": {{"arg1": "value1"}}}}
+
+Tools:
+1. get_current_datetime() -> Returns current date/time.
+2. search_web(query: str) -> Search internet for info.
+3. schedule_reminder(time_str: str, message: str) -> Schedule a reminder. 
+   - time_str MUST be in "YYYY-MM-DD HH:MM:SS" format. 
+   - If the user gives a relative time (e.g., "in 10 mins"), CALCULATE the absolute time based on Current Time.
+4. list_reminders() -> List pending reminders for the user.
+5. delete_reminder(reminder_id: int) -> Delete a reminder.
+
+RULES:
+- Always check the Current Time before scheduling.
+- If the user asks for a reminder, you MUST calculate the exact "YYYY-MM-DD HH:MM:SS" and use `schedule_reminder`.
+- If you need to answer a question about recent events, use `search_web`.
+- If you are just chatting, reply with plain text.
+"""
+
+    def _get_history(self, chat_id):
+        if chat_id not in self.histories:
+            self.histories[chat_id] = [{"role": "system", "content": self._get_system_prompt()}]
+        else:
+            # Update system prompt with fresh time
+            self.histories[chat_id][0]["content"] = self._get_system_prompt()
+        return self.histories[chat_id]
+
+    def _process_tool_call(self, response_text):
+        try:
+            match = re.search(r'\{.*\}', response_text, re.DOTALL)
+            if not match:
+                return None
+            data = json.loads(match.group(0))
+            if "tool" in data and "args" in data:
+                return data
+        except:
+            pass
+        return None
+
+    def _run_tool(self, tool_data, chat_id):
+        name = tool_data["tool"]
+        args = tool_data["args"]
+        
+        logger.info(f"Executing tool {name} for chat {chat_id}")
+
+        if name == "get_current_datetime":
+            return get_current_datetime()
+        elif name == "search_web":
+            return search_web(args.get("query"))
+        elif name == "schedule_reminder":
+            # We need to hook this into the actual scheduler in main.py.
+            # Ideally, the Agent should return this intent to the Main loop, 
+            # or the ReminderManager handles the DB and Main loop watches the DB.
+            # For simplicity: Agent updates DB via ReminderManager. 
+            # Main loop (Scheduler) should refresh or listen to changes.
+            # BUT: `schedule_reminder` here just updates the JSON. 
+            # The Scheduler in `main.py` needs to be aware of new jobs.
+            # We will return a special signal or just update the DB and assume Main reloads or we return a callback result.
+            return self.reminder_manager.add_reminder(chat_id, args.get("time_str"), args.get("message"))
+        elif name == "list_reminders":
+            return self.reminder_manager.list_reminders(chat_id)
+        elif name == "delete_reminder":
+            return self.reminder_manager.delete_reminder(chat_id, int(args.get("reminder_id")))
+        else:
+            return f"Unknown tool: {name}"
+
+    def chat(self, chat_id, user_input):
+        history = self._get_history(chat_id)
+        history.append({"role": "user", "content": user_input})
+        
+        # Simple ReAct loop
+        for _ in range(5):
+            try:
+                completion = self.client.chat.completions.create(
+                    messages=history,
+                    model=self.model,
+                    temperature=0.5
+                )
+                response = completion.choices[0].message.content
+            except Exception as e:
+                return f"Error calling Groq: {e}"
+
+            tool_data = self._process_tool_call(response)
+            
+            if tool_data:
+                history.append({"role": "assistant", "content": response})
+                
+                tool_result = self._run_tool(tool_data, chat_id)
+                
+                history.append({"role": "system", "content": f"TOOL_RESULT: {tool_result}"})
+                
+                # If it was a reminder scheduling, we might want to inform the caller (main.py) 
+                # to update the scheduler.
+                # For now, we just continue the conversation loop.
+            else:
+                history.append({"role": "assistant", "content": response})
+                
+                # Limit history size
+                if len(history) > 20:
+                    history = [history[0]] + history[-19:]
+                self.histories[chat_id] = history
+                
+                return response
+                
+        return "I'm getting confused. Let's stop here."
+
+    def generate_reminder_message(self, chat_id, reminder_message):
+        """
+        Called when a scheduled reminder triggers. 
+        Generates a friendly notification message.
+        """
+        prompt = [
+            {"role": "system", "content": "You are Jade. It is time to remind the user of something."},
+            {"role": "user", "content": f"The reminder is: '{reminder_message}'. Write a friendly message to send to the user now."}
+        ]
+        try:
+            completion = self.client.chat.completions.create(
+                messages=prompt,
+                model=self.model,
+                temperature=0.7
+            )
+            return completion.choices[0].message.content
+        except Exception as e:
+            return f"Reminder: {reminder_message}"

main.py

@@ -0,0 +1,114 @@
+import os
+import logging
+import asyncio
+from datetime import datetime
+from telegram import Update
+from telegram.ext import ApplicationBuilder, ContextTypes, CommandHandler, MessageHandler, filters
+
+# Import Agent and ReminderManager
+try:
+    from .core import TelegramJadeAgent
+    from .tools import ReminderManager
+except ImportError:
+    from core import TelegramJadeAgent
+    from tools import ReminderManager
+
+# Logging
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.INFO
+)
+logger = logging.getLogger(__name__)
+
+# Global instances
+reminder_manager = ReminderManager()
+agent = TelegramJadeAgent(reminder_manager=reminder_manager)
+
+async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    await context.bot.send_message(chat_id=update.effective_chat.id, text="Hi! I'm Jade, your 24h assistant. How can I help you?")
+
+async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    chat_id = update.effective_chat.id
+    user_text = update.message.text
+    
+    # 1. Get response from Agent
+    # agent.chat is blocking (sync), so we wrap it.
+    response = await asyncio.to_thread(agent.chat, chat_id, user_text)
+    
+    await context.bot.send_message(chat_id=chat_id, text=response)
+
+async def send_reminder_job(context: ContextTypes.DEFAULT_TYPE):
+    """Callback function for the scheduled job."""
+    job_data = context.job.data
+    chat_id = job_data["chat_id"]
+    reminder_message = job_data["message"]
+    reminder_id = job_data["id"]
+    
+    # Check if reminder is still valid (not deleted)
+    current_reminders = reminder_manager.get_due_reminders()
+    if not any(r["id"] == reminder_id for r in current_reminders):
+        logger.info(f"Reminder {reminder_id} skipped (deleted or sent).")
+        return
+
+    logger.info(f"Triggering reminder {reminder_id} for chat {chat_id}")
+    
+    # Generate message via Agent
+    text = await asyncio.to_thread(agent.generate_reminder_message, chat_id, reminder_message)
+    
+    await context.bot.send_message(chat_id=chat_id, text=text)
+    
+    # Mark as sent
+    reminder_manager.mark_as_sent(reminder_id)
+
+async def check_reminders_loop(context: ContextTypes.DEFAULT_TYPE):
+    """
+    Background task running every X seconds to check for new reminders in DB
+    and schedule them in the JobQueue.
+    """
+    pending = reminder_manager.get_due_reminders()
+    job_queue = context.job_queue
+    
+    # Get current scheduled jobs by name
+    current_jobs = [j.name for j in job_queue.jobs()]
+    
+    for r in pending:
+        job_name = f"reminder_{r['id']}"
+        if job_name not in current_jobs:
+            try:
+                run_date = datetime.strptime(r["time"], "%Y-%m-%d %H:%M:%S")
+                
+                # If time is in past, schedule for immediate execution
+                if run_date < datetime.now():
+                    run_date = datetime.now()
+                
+                logger.info(f"Scheduling {job_name} for {run_date}")
+                
+                job_queue.run_once(
+                    send_reminder_job, 
+                    when=run_date, 
+                    data=r, 
+                    name=job_name
+                )
+            except Exception as e:
+                logger.error(f"Failed to schedule {job_name}: {e}")
+
+if __name__ == '__main__':
+    token = os.getenv("TELEGRAM_BOT_TOKEN")
+    if not token:
+        print("Error: TELEGRAM_BOT_TOKEN not found.")
+        exit(1)
+        
+    application = ApplicationBuilder().token(token).build()
+    
+    start_handler = CommandHandler('start', start)
+    msg_handler = MessageHandler(filters.TEXT & (~filters.COMMAND), handle_message)
+    
+    application.add_handler(start_handler)
+    application.add_handler(msg_handler)
+    
+    # Add a repeating job to sync reminders (e.g. every 10 seconds)
+    if application.job_queue:
+        application.job_queue.run_repeating(check_reminders_loop, interval=10, first=1)
+    
+    print("Jade Telegram Bot is running...")
+    application.run_polling()

requirements.txt

@@ -0,0 +1,4 @@
+python-telegram-bot
+groq
+APScheduler
+duckduckgo-search

tools.py

@@ -0,0 +1,109 @@
+import json
+import os
+import logging
+from datetime import datetime
+from duckduckgo_search import DDGS
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+def get_current_datetime() -> str:
+    """Returns the current date and time as a formatted string."""
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+def search_web(query: str) -> str:
+    """Searches the web using DuckDuckGo and returns the top results."""
+    try:
+        with DDGS() as ddgs:
+            results = list(ddgs.text(query, max_results=3))
+        if not results:
+            return "No results found."
+        
+        formatted_results = []
+        for i, res in enumerate(results, 1):
+            formatted_results.append(f"{i}. {res['title']}: {res['body']} (URL: {res['href']})")
+        
+        return "\n".join(formatted_results)
+    except Exception as e:
+        return f"Error searching web: {str(e)}"
+
+class ReminderManager:
+    def __init__(self, storage_file="telegram_jade/reminders.json"):
+        self.storage_file = storage_file
+        self.reminders = []
+        self._load_reminders()
+
+    def _load_reminders(self):
+        if os.path.exists(self.storage_file):
+            try:
+                with open(self.storage_file, 'r') as f:
+                    self.reminders = json.load(f)
+            except json.JSONDecodeError:
+                logger.error(f"Error decoding {self.storage_file}. Starting with empty reminders.")
+                self.reminders = []
+        else:
+            self.reminders = []
+
+    def _save_reminders(self):
+        # Ensure directory exists
+        os.makedirs(os.path.dirname(self.storage_file), exist_ok=True)
+        with open(self.storage_file, 'w') as f:
+            json.dump(self.reminders, f, indent=2)
+
+    def add_reminder(self, chat_id: int, time_str: str, message: str):
+        """
+        Adds a reminder.
+        time_str format: "YYYY-MM-DD HH:MM:SS"
+        """
+        # Generate ID safely
+        if self.reminders:
+            new_id = max(r["id"] for r in self.reminders) + 1
+        else:
+            new_id = 1
+
+        reminder = {
+            "id": new_id,
+            "chat_id": chat_id,
+            "time": time_str,
+            "message": message,
+            "status": "pending"
+        }
+        self.reminders.append(reminder)
+        self._save_reminders()
+        return f"Reminder set for {time_str}: {message}"
+
+    def list_reminders(self, chat_id: int):
+        """Lists pending reminders for a specific chat."""
+        user_reminders = [r for r in self.reminders if r["chat_id"] == chat_id and r["status"] == "pending"]
+        if not user_reminders:
+            return "No pending reminders."
+        
+        result = "Pending Reminders:\n"
+        for r in user_reminders:
+            result += f"- [{r['time']}] {r['message']} (ID: {r['id']})\n"
+        return result
+
+    def delete_reminder(self, chat_id: int, reminder_id: int):
+        """Deletes a reminder by ID."""
+        for i, r in enumerate(self.reminders):
+            if r["id"] == reminder_id and r["chat_id"] == chat_id:
+                del self.reminders[i]
+                self._save_reminders()
+                return f"Reminder ID {reminder_id} deleted."
+        return f"Reminder ID {reminder_id} not found."
+
+    def get_due_reminders(self):
+        """
+        Returns a list of reminders that are due now or in the past and mark them as sent?
+        Actually, the scheduler will likely handle the trigger logic, but we need a way to
+        retrieve 'active' reminders to schedule them on startup.
+        """
+        return [r for r in self.reminders if r["status"] == "pending"]
+    
+    def mark_as_sent(self, reminder_id: int):
+        for r in self.reminders:
+            if r["id"] == reminder_id:
+                r["status"] = "sent"
+                self._save_reminders()
+                return