Update jarvis.py

jarvis.py

@@ -7,14 +7,15 @@ from pyrogram import Client, filters
 from pyrogram.enums import ParseMode
 import google.generativeai as genai
 import subprocess
+import traceback
 
-# check line 93 .. accordingly
 # === CONFIG ===
-API_ID = os.environ.get("API_ID")                 # Replace with your API ID
-API_HASH = os.environ.get("API_HASH")   # Replace with your API HASH
+API_ID = os.environ.get("API_ID")
+API_HASH = os.environ.get("API_HASH")
 BOT_TOKEN = os.environ.get("BOT_TOKEN")
 GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
-OWNER_ID = int(os.environ.get("OWNER_ID", "7361622601"))  # Owner user ID
+OWNER_ID = int(os.environ.get("OWNER_ID", "7361622601"))
+
 if not BOT_TOKEN:
     raise RuntimeError("BOT_TOKEN environment variable not set!")
 if not GEMINI_API_KEY:
@@ -28,19 +29,25 @@ os.makedirs("modules", exist_ok=True)
 
 # === MODULE LOADER ===
 def load_modules(folder="modules"):
+    loaded_count = 0
     for file in os.listdir(folder):
         if file.endswith(".py"):
-            path = os.path.join(folder, file)
-            name = file[:-3]
-            spec = importlib.util.spec_from_file_location(name, path)
-            mod = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(mod)
-
-load_modules()
+            try:
+                path = os.path.join(folder, file)
+                name = file[:-3]
+                spec = importlib.util.spec_from_file_location(name, path)
+                mod = importlib.util.module_from_spec(spec)
+                mod.bot = bot  # Inject bot instance
+                spec.loader.exec_module(mod)
+                loaded_count += 1
+                print(f"✅ Loaded module: {name}")
+            except Exception as e:
+                print(f"❌ Failed to load {file}: {e}")
+    print(f"📦 Loaded {loaded_count} modules")
 
 # === HELPERS ===
 def extract_module_name(code: str) -> str:
-    match = re.search(r"def\\s+([a-zA-Z_][a-zA-Z0-9_]*)", code)
+    match = re.search(r"def\s+([a-zA-Z_][a-zA-Z0-9_]*)", code)
     return match.group(1).lower() if match else f"mod_{os.urandom(2).hex()}"
 
 def extract_commands(code: str) -> list:
@@ -48,86 +55,161 @@ def extract_commands(code: str) -> list:
 
 def determine_intent(text: str) -> str:
     lowered = text.lower()
-    if any(x in lowered for x in ["create", "make", "build"]):
+    if any(x in lowered for x in ["create", "make", "build", "generate", "add"]):
         return "CREATE"
-    elif any(x in lowered for x in ["edit", "modify"]):
+    elif any(x in lowered for x in ["edit", "modify", "update", "change"]):
         return "EDIT"
     elif "recode" in lowered:
         return "RECODE"
     else:
-        return "UNSURE"
+        return "CREATE"  # Default to CREATE instead of UNSURE
 
 def clean_code_blocks(code: str) -> str:
-    if code.startswith("```python"):
-        code = code[9:]
-    if code.startswith("```"):
-        code = code[3:]
-    if code.endswith("```"):
-        code = code[:-3]
+    # Remove markdown code blocks
+    code = re.sub(r'^```python\n?', '', code, flags=re.MULTILINE)
+    code = re.sub(r'^```\n?', '', code, flags=re.MULTILINE)
+    code = re.sub(r'\n?```$', '', code, flags=re.MULTILINE)
     return code.strip()
 
 def extract_module_name_from_description(description: str) -> str:
-    # Improved module name extraction - focus on key nouns and actions
-    import re
-    
-    # Common words to remove
+    """Enhanced module name extraction"""
     stopwords = {
         'jarvis', 'make', 'create', 'build', 'generate', 'a', 'an', 'the', 'please', 'module', 
         'for', 'me', 'to', 'with', 'add', 'new', 'of', 'system', 'bot', 'command', 'that', 'and', 
         'in', 'on', 'by', 'as', 'is', 'it', 'my', 'this', 'do', 'can', 'you', 'i', 'want', 'need', 
         'from', 'like', 'using', 'feature', 'function', 'implement', 'write', 'code', 'file', 
-        'python', 'telegram', 'pyrogram', 'handler', 'example', 'mod', 'mod_', 'particular', 'user'
+        'python', 'telegram', 'pyrogram', 'handler', 'example', 'mod', 'particular', 'user'
     }
     
-    # Clean the description
+    # Extract meaningful words
     desc = re.sub(r'[^a-zA-Z0-9_\s]', ' ', description.lower())
-    words = desc.split()
-    
-    # Filter out stopwords and short words
-    filtered_words = []
-    for word in words:
-        if word not in stopwords and len(word) > 2:
-            filtered_words.append(word)
+    words = [w for w in desc.split() if w not in stopwords and len(w) > 2]
     
-    # If we have good words, use them
-    if filtered_words:
-        # Take up to 3 most relevant words
-        name_words = filtered_words[:3]
-        name = '_'.join(name_words)
+    if words:
+        name = '_'.join(words[:2])  # Take first 2 meaningful words
     else:
-        # Fallback: extract any meaningful word
-        meaningful_words = [w for w in words if len(w) > 3 and w not in stopwords]
-        if meaningful_words:
-            name = meaningful_words[0]
-        else:
-            # Last resort: use first few characters
-            clean_desc = re.sub(r'[^a-zA-Z0-9]', '', description.lower())
-            name = clean_desc[:10] if clean_desc else f"mod_{os.urandom(2).hex()}"
+        # Fallback to extracting from original description
+        clean_desc = re.sub(r'[^a-zA-Z0-9]', '', description.lower())
+        name = clean_desc[:10] if clean_desc else f"mod_{os.urandom(2).hex()}"
     
-    # Clean up the name
-    name = re.sub(r'_+', '_', name).strip('_')
-    name = name.lower()
+    # Clean and validate
+    name = re.sub(r'_+', '_', name).strip('_').lower()
+    return name if name else f"mod_{os.urandom(2).hex()}"
+
+def get_improved_prompt(description: str, attempt: int = 1, last_error: str = None) -> str:
+    """Generate improved prompts for better code generation"""
     
-    # Ensure it's not empty
-    if not name:
-        name = f"mod_{os.urandom(2).hex()}"
+    base_prompt = f"""You are an expert Python developer creating a Pyrogram Telegram bot module.
+
+TASK: Create a module that implements: {description}
+
+CRITICAL REQUIREMENTS:
+1. Use the existing 'bot' variable - DO NOT create a new Client instance
+2. Import bot using this exact pattern:
+   ```python
+   try:
+       from __main__ import bot
+   except ImportError:
+       from ..main import bot
+   ```
+3. Import only necessary Pyrogram components:
+   ```python
+   from pyrogram import filters
+   from pyrogram.enums import ParseMode
+   ```
+4. Use proper async/await for all bot operations
+5. Handle errors gracefully with try/except blocks
+6. Include proper message validation and user feedback
+
+HANDLER PATTERN:
+```python
+@bot.on_message(filters.command("commandname") & filters.private)
+async def function_name(client, message):
+    try:
+        # Your code here
+        await message.reply("Response")
+    except Exception as e:
+        await message.reply(f"❌ Error: {{str(e)}}")
+```
+
+SPECIFIC GUIDELINES:
+- Only create commands explicitly mentioned in the request
+- Use descriptive function names
+- Include input validation
+- Provide helpful error messages
+- Use markdown formatting for responses when appropriate
+- Handle edge cases (empty inputs, invalid data, etc.)
+
+CODE STRUCTURE:
+- Start with imports
+- Define helper functions if needed
+- Create command handlers
+- No main execution code (no if __name__ == "__main__")
+
+OUTPUT: Provide ONLY the Python code, no explanations or markdown formatting."""
+
+    if attempt > 1 and last_error:
+        base_prompt += f"\n\nPREVIOUS ERROR TO FIX: {last_error}\n"
+        base_prompt += "Make sure to address this specific error in your implementation."
     
-    return name
+    return base_prompt
+
+def get_edit_prompt(file_path: str, current_content: str, edit_instruction: str) -> str:
+    """Generate prompt for editing existing modules"""
+    return f"""You are an expert Python developer. Edit the following Pyrogram bot module.
+
+CURRENT FILE: {file_path}
+CURRENT CONTENT:
+```python
+{current_content}
+```
+
+EDIT INSTRUCTION: {edit_instruction}
+
+REQUIREMENTS:
+1. Maintain the existing import structure
+2. Keep the bot variable usage consistent
+3. Preserve working functionality while making requested changes
+4. Follow the same coding patterns as the existing code
+5. Add proper error handling for new features
+
+OUTPUT: Provide ONLY the complete updated Python code, no explanations."""
 
 async def restart_bot(chat_id):
-    await bot.send_message(chat_id, "♻️ Restarting to apply new module...")
+    """Restart the bot to load new modules"""
+    await bot.send_message(chat_id, "♻️ Restarting to apply changes...")
+    await asyncio.sleep(1)
     await bot.stop()
     os.execl(sys.executable, sys.executable, *sys.argv)
-    os._exit(0)  # Ensure process exits if execl fails
 
-# === WORD TRIGGER ===
+def validate_generated_code(code: str) -> tuple[bool, str]:
+    """Validate generated code before saving"""
+    if not code.strip():
+        return False, "Empty code generated"
+    
+    if "def " not in code:
+        return False, "No function definitions found"
+    
+    if "@bot.on_message" not in code:
+        return False, "No message handlers found"
+    
+    if "import" not in code:
+        return False, "No imports found"
+    
+    # Check for common issues
+    if "Client(" in code:
+        return False, "Code creates new Client instance (should use existing bot)"
+    
+    if "__main__" in code and "if __name__" in code:
+        return False, "Code contains main execution block (not allowed in modules)"
+    
+    return True, "Code validation passed"
+
+# === MAIN HANDLER ===
 @bot.on_message(filters.private & filters.text)
 async def jarvis_trigger(client, message):
     # Owner-only access control
-    print(f"DEBUG: User ID: {message.from_user.id}, Expected: {OWNER_ID}")
-    print(f"DEBUG: User: {message.from_user.first_name} {message.from_user.last_name}")
     if message.from_user.id != OWNER_ID:
-        print(f"DEBUG: Access denied for user {message.from_user.id}")
         return await message.reply("❌ Access denied. Only the owner can use this bot.")
 
     text = message.text.strip()
@@ -136,125 +218,84 @@ async def jarvis_trigger(client, message):
 
     description = text[6:].strip()
     if not description:
-        return await message.reply("🤖 Hello, what would you like me to do?")
+        return await message.reply("🤖 Hello! What would you like me to create?")
 
     intent = determine_intent(description)
-    progress_msg = await message.reply(f"🤖 Acknowledged.\n🧠 Determining intent...\n📘 Intent: {intent}\n📝 Task: `{description}`", parse_mode=ParseMode.MARKDOWN)
+    progress_msg = await message.reply(
+        f"🤖 **Jarvis Assistant**\n"
+        f"📝 Task: `{description}`\n"
+        f"🧠 Intent: {intent}\n"
+        f"⏳ Processing...", 
+        parse_mode=ParseMode.MARKDOWN
+    )
 
-    # --- NEW: Handle EDIT intent for existing files ---
+    # Handle EDIT intent
     if intent == "EDIT":
-        # Try to extract filename and edit instruction
-        match = re.match(r"edit\s+([\w/\\.]+)\s+(.*)", description, re.IGNORECASE)
-        if match:
-            file_path = match.group(1)
-            edit_instruction = match.group(2)
+        edit_match = re.match(r"edit\s+([\w/\\.]+)\s+(.*)", description, re.IGNORECASE)
+        if edit_match:
+            file_path = edit_match.group(1)
+            edit_instruction = edit_match.group(2)
+            
             if not os.path.exists(file_path):
-                await progress_msg.edit(f"❌ File `{file_path}` not found.")
-                return
-            with open(file_path, "r", encoding="utf-8") as f:
-                current_content = f.read()
-            edit_prompt = (
-                f"You are an expert Python developer. Here is the current content of `{file_path}`:\n"
-                f"""\n{current_content}\n"""
-                f"Please edit this file to: {edit_instruction}.\n"
-                f"Output ONLY the new Python code, no explanations or markdown."
-            )
+                return await progress_msg.edit(f"❌ File `{file_path}` not found.")
+            
             try:
-                response = model.generate_content(edit_prompt)
+                with open(file_path, "r", encoding="utf-8") as f:
+                    current_content = f.read()
+                
+                edit_prompt = get_edit_prompt(file_path, current_content, edit_instruction)
+                
+                await progress_msg.edit(f"🔄 Editing {file_path}...")
+                response = await asyncio.to_thread(model.generate_content, edit_prompt)
                 new_code = clean_code_blocks(response.text.strip())
-                if not new_code or "def " not in new_code:
-                    await progress_msg.edit(f"❌ Edit failed: No valid code returned.")
-                    return
+                
+                is_valid, validation_msg = validate_generated_code(new_code)
+                if not is_valid:
+                    return await progress_msg.edit(f"❌ Edit failed: {validation_msg}")
+                
                 with open(file_path, "w", encoding="utf-8") as f:
                     f.write(new_code)
-                # Try to reload the module if it's in modules/
-                if file_path.startswith("modules/") and file_path.endswith(".py"):
-                    mod_name = os.path.basename(file_path)[:-3]
-                    try:
-                        spec = importlib.util.spec_from_file_location(mod_name, file_path)
-                        mod = importlib.util.module_from_spec(spec)
-                        mod.bot = bot
-                        spec.loader.exec_module(mod)
-                    except Exception as test_error:
-                        await progress_msg.edit(f"⚠️ Edit applied, but module reload failed: {test_error}")
-                        return
-                await progress_msg.edit(f"✅ Edit applied to `{file_path}`. Restarting bot...")
+                
+                await progress_msg.edit(f"✅ Successfully edited `{file_path}`\n♻️ Restarting bot...")
                 await asyncio.sleep(2)
                 asyncio.create_task(restart_bot(message.chat.id))
                 return
+                
             except Exception as e:
-                await progress_msg.edit(f"❌ Edit failed: `{str(e)[:100]}...`")
-                return
+                return await progress_msg.edit(f"❌ Edit failed: {str(e)}")
         else:
-            await progress_msg.edit("❗ Could not parse edit command. Use: 'edit <file> <instruction>'")
-            return
-    # --- END NEW ---
+            return await progress_msg.edit("❗ Format: `jarvis edit <file> <instruction>`")
 
+    # Handle CREATE intent
     success = False
-    code = ""
     last_error = None
-    for attempt in range(1, 6):
-        await progress_msg.edit(f"`Attempt {attempt}/5:` Thinking and generating code...\n- Executing prerequisite shell commands...")
-
+    
+    for attempt in range(1, 4):  # Reduced to 3 attempts
         try:
-            prompt = (
-                f"Write a full Pyrogram Telegram bot module that implements:\n"
-                f"{description}.\n\n"
-                f"IMPORTANT RULES:\n"
-                f"1. Use 'bot' variable (not 'Client') - it will be injected\n"
-                f"2. Include commands using @bot.on_message(filters.command(...))\n"
-                f"3. Import only what you need from pyrogram\n and use 'from ..t1 import bot'\n 'try: from ..t1 import bot except (ImportError, ValueError): \n from __main__ import bot' \n"
-                f"4. Don't create a new Client instance\n"
-                f"5. Make functions async when using bot methods\n"
-                f"6. ONLY create the specific commands requested - do NOT add standard commands like /start, /help, /about unless explicitly asked for\n"
-                f"7. If the user asks for '/bash', only create the /bash command, not additional commands\n\n"
-                f"Output ONLY Python code, no explanations or markdown."
+            await progress_msg.edit(
+                f"🤖 **Jarvis Assistant**\n"
+                f"📝 Task: `{description}`\n"
+                f"🧠 Intent: {intent}\n"
+                f"🔄 Attempt {attempt}/3: Generating code...",
+                parse_mode=ParseMode.MARKDOWN
             )
-            if attempt > 1 and last_error is not None:
-                prompt += f"\n\nNote: Previous attempt failed with error: {str(last_error)}. Fix that issue this time."
-
-            response = model.generate_content(prompt)
+            
+            # Generate code
+            prompt = get_improved_prompt(description, attempt, last_error)
+            response = await asyncio.to_thread(model.generate_content, prompt)
             code = clean_code_blocks(response.text.strip())
-
-            # === AUTO-FIX COMMON LLM MISTAKES ===
-            code = code.replace('asyncio.PIPE', 'subprocess.PIPE')
-            # Add more auto-fixes as needed
-
-            # === REMOVE UNWANTED STANDARD COMMANDS ===
-            # Only keep commands that were explicitly requested
-            import re
-            requested_commands = []
-            # Extract commands mentioned in the description
-            cmd_matches = re.findall(r'/(\w+)', description.lower())
-            if cmd_matches:
-                requested_commands = [f'/{cmd}' for cmd in cmd_matches]
             
-            # If specific commands were requested, remove unwanted standard commands
-            if requested_commands:
-                unwanted_commands = ['/start', '/help', '/about', '/info']
-                for unwanted in unwanted_commands:
-                    if unwanted not in requested_commands:
-                        # Remove the entire function/handler for unwanted commands
-                        pattern = rf'@bot\.on_message\(filters\.command\(["\']{unwanted[1:]}["\']\)\).*?(?=@bot\.on_message|$)'
-                        code = re.sub(pattern, '', code, flags=re.DOTALL)
-
-            # === LINTER/STATIC CHECKER ===
-            with open('tmp_lint_module.py', 'w', encoding='utf-8') as tmpf:
-                tmpf.write(code)
-            lint_proc = subprocess.run(['pyflakes', 'tmp_lint_module.py'], capture_output=True, text=True)
-            if lint_proc.returncode != 0 or lint_proc.stdout.strip() or lint_proc.stderr.strip():
-                lint_output = (lint_proc.stdout + '\n' + lint_proc.stderr).strip()
-                await progress_msg.edit(f"❌ Linter/static check failed!\n\n```\n{lint_output}\n```")
-                os.remove('tmp_lint_module.py')
-                continue
-            os.remove('tmp_lint_module.py')
-
-            if "def " not in code or "@bot" not in code:
-                await progress_msg.edit(f"❌ Attempt {attempt}: Invalid function or handler.")
+            # Validate generated code
+            is_valid, validation_msg = validate_generated_code(code)
+            if not is_valid:
+                last_error = validation_msg
                 continue
-
-            # --- NEW: Use file path from description if present ---
-            import re
+            
+            # Auto-fix common issues
+            code = code.replace('asyncio.PIPE', 'subprocess.PIPE')
+            code = code.replace('asyncio.create_subprocess_shell', 'subprocess.run')
+            
+            # Determine module name and path
             file_path_match = re.search(r"(modules/[\w\-]+\.py)", description)
             if file_path_match:
                 mod_path = file_path_match.group(1)
@@ -262,145 +303,143 @@ async def jarvis_trigger(client, message):
             else:
                 mod_name = extract_module_name_from_description(description)
                 mod_path = f"modules/{mod_name}.py"
-            # If file exists, use edit flow instead of creating a new file
-            if os.path.exists(mod_path):
-                with open(mod_path, "r", encoding="utf-8") as f:
-                    current_content = f.read()
-                edit_prompt = (
-                    f"You are an expert Python developer. Here is the current content of `{mod_path}`:\n"
-                    f"""\n{current_content}\n"""
-                    f"Please update this file to: {description}.\n"
-                    f"Output ONLY the new Python code, no explanations or markdown."
-                )
-                response = model.generate_content(edit_prompt)
-                code = clean_code_blocks(response.text.strip())
-            # --- END NEW ---
-
+            
+            # Save the module
+            await progress_msg.edit(
+                f"🤖 **Jarvis Assistant**\n"
+                f"📝 Task: `{description}`\n"
+                f"🧠 Intent: {intent}\n"
+                f"💾 Saving module: {mod_name}...",
+                parse_mode=ParseMode.MARKDOWN
+            )
+            
             with open(mod_path, "w", encoding="utf-8") as f:
                 f.write(code)
-
-            await progress_msg.edit(f"`Attempt {attempt}/5: Thinking and generating code...\n- Executing prerequisite shell commands...\n- Testing generated code...")
-
+            
+            # Test the module
+            await progress_msg.edit(
+                f"🤖 **Jarvis Assistant**\n"
+                f"📝 Task: `{description}`\n"
+                f"🧠 Intent: {intent}\n"
+                f"🧪 Testing module...",
+                parse_mode=ParseMode.MARKDOWN
+            )
+            
             try:
                 spec = importlib.util.spec_from_file_location(mod_name, mod_path)
                 mod = importlib.util.module_from_spec(spec)
                 mod.bot = bot
                 spec.loader.exec_module(mod)
             except Exception as test_error:
-                raise RuntimeError(f"Testing error: {test_error}")
-
-            await progress_msg.edit(f"`Attempt {attempt}/5:` Thinking and generating code...\n- Executing prerequisite shell commands...\n- Testing generated code...\n- Tests passed. Writing files...\n- Files written. Initiating restart...")
-
-            # === NEW: Show module details before restart ===
-            try:
-                commands = extract_commands(code)
-                commands_str = ', '.join(f'/{cmd}' for cmd in commands) if commands else 'No commands found.'
-            except Exception as cmd_error:
-                commands_str = f'Error extracting commands: {cmd_error}'
+                last_error = f"Module test failed: {str(test_error)}"
+                continue
             
+            # Success! Show details
             try:
-                explain_prompt = (
-                    f"Explain in 2-3 sentences what this Pyrogram Telegram bot module does, given the following code and the user's request.\n"
-                    f"User request: {description}\n"
-                    f"Module code:\n{code}\n"
-                    f"Be concise and clear."
-                )
-                explain_response = model.generate_content(explain_prompt)
+                commands = extract_commands(code)
+                commands_str = ', '.join(f'/{cmd}' for cmd in commands) if commands else 'No commands found'
+                
+                # Generate explanation
+                explain_prompt = f"""Briefly explain what this Telegram bot module does based on the user's request and the code.
+
+User request: {description}
+Commands found: {commands_str}
+
+Provide a concise 1-2 sentence explanation."""
+                
+                explain_response = await asyncio.to_thread(model.generate_content, explain_prompt)
                 explanation = explain_response.text.strip()
-            except Exception as exp_explain:
-                explanation = f"Could not generate explanation: {exp_explain}"
-            
-            try:
-                details_msg = (
-                    f"✅ Module created successfully!\n\n"
-                    f"**Commands:** {commands_str}\n\n"
-                    f"**What it does:**\n{explanation}\n\n"
-                    f"♻️ Restarting bot to load the new module..."
+                
+                await progress_msg.edit(
+                    f"✅ **Module Created Successfully!**\n\n"
+                    f"📄 **File:** `{mod_path}`\n"
+                    f"🔧 **Commands:** {commands_str}\n"
+                    f"📋 **Description:** {explanation}\n\n"
+                    f"♻️ Restarting bot to load the module...",
+                    parse_mode=ParseMode.MARKDOWN
                 )
-                await progress_msg.edit(details_msg, parse_mode=ParseMode.MARKDOWN)
-            except Exception as msg_error:
-                # Fallback message if formatting fails
-                await progress_msg.edit(f"✅ Module created successfully! Commands: {commands_str}\n\nWhat it does: {explanation}\n\n♻️ Restarting bot...")
-            # === END NEW ===
+                
+            except Exception:
+                await progress_msg.edit(
+                    f"✅ **Module Created Successfully!**\n\n"
+                    f"📄 **File:** `{mod_path}`\n"
+                    f"🔧 **Commands:** {commands_str}\n\n"
+                    f"♻️ Restarting bot to load the module...",
+                    parse_mode=ParseMode.MARKDOWN
+                )
+            
             await asyncio.sleep(2)
             asyncio.create_task(restart_bot(message.chat.id))
             success = True
             break
-
+            
         except Exception as e:
-            last_error = e
-            error_msg = f"❌ Attempt {attempt} Error: {str(e)}"
-            print(f"DEBUG: Module generation error on attempt {attempt}: {e}")
-            print(f"DEBUG: Error type: {type(e).__name__}")
-            try:
-                await progress_msg.edit(error_msg[:100] + "..." if len(error_msg) > 100 else error_msg)
-            except Exception as edit_error:
-                print(f"DEBUG: Failed to edit progress message: {edit_error}")
-                # Try to send a new message if editing fails
-                try:
-                    await message.reply(f"❌ Attempt {attempt} failed. Check logs for details.")
-                except:
-                    pass
-
+            last_error = str(e)
+            print(f"❌ Attempt {attempt} failed: {e}")
+            print(f"❌ Traceback: {traceback.format_exc()}")
+    
     if not success:
-        await progress_msg.edit("❌ All 5 attempts failed. Please try again with a simpler instruction.")
-
-# === /modules ===
+        await progress_msg.edit(
+            f"❌ **Failed to create module**\n\n"
+            f"All attempts failed. Last error:\n`{last_error}`\n\n"
+            f"Please try with a simpler request or check the logs.",
+            parse_mode=ParseMode.MARKDOWN
+        )
+
+# === UTILITY COMMANDS ===
 @bot.on_message(filters.command("modules") & filters.private)
 async def list_modules(client, message):
-    # Owner-only access control
     if message.from_user.id != OWNER_ID:
-        return await message.reply("❌ Access denied. Only the owner can use this bot.")
+        return await message.reply("❌ Access denied.")
 
     modules = [f for f in os.listdir("modules") if f.endswith(".py")]
     if modules:
-        module_list = "\n".join([f"• {m[:-3]}" for m in modules])
-        await message.reply(f" Loaded Modules: \n{module_list}", parse_mode=ParseMode.MARKDOWN)
+        module_list = "\n".join([f"• `{m[:-3]}`" for m in modules])
+        await message.reply(f"📦 **Loaded Modules:**\n{module_list}", parse_mode=ParseMode.MARKDOWN)
     else:
-        await message.reply(" No modules found.", parse_mode=ParseMode.MARKDOWN)
+        await message.reply("📦 **No modules found.**", parse_mode=ParseMode.MARKDOWN)
 
-# === /delete ===
 @bot.on_message(filters.command("delete") & filters.private)
 async def delete_module(client, message):
-    # Owner-only access control
     if message.from_user.id != OWNER_ID:
-        return await message.reply("❌ Access denied. Only the owner can use this bot.")
+        return await message.reply("❌ Access denied.")
 
     if len(message.command) < 2:
-        return await message.reply("❗ Specify module name.\n\nExample: `/delete calculator`", parse_mode=ParseMode.MARKDOWN)
+        return await message.reply("❗ **Usage:** `/delete <module_name>`", parse_mode=ParseMode.MARKDOWN)
     
     mod_name = message.command[1].lower()
     mod_path = f"modules/{mod_name}.py"
     
     if os.path.exists(mod_path):
         os.remove(mod_path)
-        await message.reply(f"🗑 Deleted `{mod_name}.py`\n♻️ Restart required to take effect.", parse_mode=ParseMode.MARKDOWN)
+        await message.reply(f"🗑 **Deleted:** `{mod_name}.py`\n♻️ Restart required.", parse_mode=ParseMode.MARKDOWN)
     else:
         await message.reply(f"❌ Module `{mod_name}.py` not found.", parse_mode=ParseMode.MARKDOWN)
 
-# === /what to do ===
-@bot.on_message(filters.regex(r"(?i)what( can)? i do\??") & filters.private)
-async def what_to_do(_, message):
-    # Owner-only access control
+@bot.on_message(filters.regex(r"(?i)(what|help|commands)") & filters.private)
+async def help_command(_, message):
     if message.from_user.id != OWNER_ID:
-        return await message.reply("❌ Access denied. Only the owner can use this bot.")
+        return await message.reply("❌ Access denied.")
 
     await message.reply(
-        "**🧠 Jarvis Assistant**\n\n"
-        "I can generate custom bot modules for you!\n\n"
+        "🤖 **Jarvis Assistant - Help**\n\n"
+        "**Natural Language:**\n"
+        "• `jarvis create a calculator`\n"
+        "• `jarvis make a weather bot`\n"
+        "• `jarvis build a reminder system`\n\n"
         "**Commands:**\n"
-        "`jarvis make a calculator` - Natural language trigger\n"
-        "`/modules` - List all modules\n"
-        "`/delete <name>` - Delete a module\n\n"
+        "• `/modules` - List all modules\n"
+        "• `/delete <name>` - Delete a module\n\n"
         "**Examples:**\n"
-        "`jarvis build a reminder system`\n"
-        "`jarvis create a dice game`\n"
-        "`jarvis weather checker`\n",
+        "• `jarvis create a /joke command`\n"
+        "• `jarvis make a password generator`\n"
+        "• `jarvis build a text to speech module`\n",
         parse_mode=ParseMode.MARKDOWN
     )
 
-# === START ===
-print("🚀 Starting Jarvis Bot...")
-load_modules()
-print("✅ Bot is ready!")
-bot.run()
+# === STARTUP ===
+if __name__ == "__main__":
+    print("🚀 Starting Jarvis Bot...")
+    load_modules()
+    print("✅ Bot is ready!")
+    bot.run()