Update app.py

app.py

@@ -1,18 +1,59 @@
+"""
+Project Name: Autonomous AI Orchestrator
+
+Description:
+An end-to-end, self-improving AI agent framework that takes user goals and autonomously:
+
+- Plans multi-step workflows (Research, Learn, Develop, Execute, Diagnose, Review)
+- Performs web searches and aggregates reliable information
+- Generates and safely executes Python code
+- Self-evaluates and optimizes its own processes
+- Provides a Learning Coach for personalized, source-backed teaching
+- Persists session memory, logs activities, and snapshots full state for audit and rollback
+
+Instructions:
+1. **Dependencies**: Ensure your `requirements.txt` contains:
+   ```
+   duckduckgo-search
+   gradio
+   requests
+   python-dotenv
+   feedparser
+   ```
+2. **Module Structure**: Place the following modules alongside your main script (`app.py`):
+   - `memory.py`
+   - `planner.py`
+   - `executor.py`
+   - `critic.py`
+   - `cognitive_engine.py`
+   - `web_searcher.py`
+   - `hf_packager.py`
+   - (Optional CSS: `style.css` for UI styling)
+3. **Run the Application**:
+   ```bash
+   python app.py
+   ```
+4. **Access Interfaces**:
+   - **Gradio UI**: Navigate to `http://<host>:<port>/ui` for Task Execution and Learning Coach tabs
+   - **API Endpoints**:
+     - `GET /status` — Health check and available routes
+     - `GET /generate?prompt=<text>` — Quick text generation
+     - `POST /generate` — JSON-based generation with session tracking
+     - `GET /memory/{session_id}` — Retrieve session history
+     - `GET /summary/{session_id}` — Summarize recent interactions
+5. **Persistence & Logs**:
+   - Activity logs in `log.txt`
+   - Session memory stored in `memory.json`
+   - Snapshots saved under `snapshots/` with recoverable JSON files
+"""
+
 import os
 import zipfile
 import base64
-
-def create_autonomous_ai_package():
-    # Create project directory structure
-    os.makedirs("Autonomous-AI-System", exist_ok=True)
-    
-    # Define all files with their content
-    files = {
-        "app.py": """import gradio as gr
+import gradio as gr
 import uuid
 import json
 import logging
-import os
 import datetime
 from memory import MemoryManager
 from planner import Planner
@@ -70,857 +111,67 @@ class AutonomousAgent:
             # Execute plan
             results = []
             for step in plan:
-                if "research" in step.lower() or "search" in step.lower():
-                    # Perform web search
-                    search_query = step.split(":")[1].strip() if ":" in step else goal
-                    search_results = web_searcher.search(search_query)
-                    memory.add(session_id, f"search:{search_query}", search_results)
-                    results.append(f"🔍 Search results for '{search_query}':\\n{search_results[:500]}...")
-                
-                elif "develop" in step.lower() or "code" in step.lower():
-                    # Generate and execute code
+                key = step.split(":")[0].lower()
+                if key in ["research", "search"]:
+                    query = step.split(":",1)[1].strip()
+                    res = web_searcher.search(query)
+                    memory.add(session_id, f"search:{query}", res)
+                    results.append(f"🔍 Search '{query}': {res[:300]}...")
+                elif key in ["develop", "code"]:
                     code = cog_engine.generate_code(step, memory.get(session_id))
-                    execution_result = executor.execute_code(code)
+                    out = executor.execute_code(code)
                     memory.add(session_id, "generated_code", code)
-                    memory.add(session_id, "execution_result", execution_result)
-                    
-                    # Review and improve
-                    review = critic.review(step, execution_result)
+                    memory.add(session_id, "execution_result", out)
+                    review = critic.review(step, out)
                     memory.add(session_id, "review", review)
-                    
-                    if "error" in review.lower() or "improve" in review.lower():
-                        enhanced_code = cog_engine.improve_code(code, review)
-                        memory.add(session_id, "enhanced_code", enhanced_code)
-                        execution_result = executor.execute_code(enhanced_code)
-                        results.append(f"🛠️ Enhanced code execution:\\n{execution_result}")
+                    if "error" in review.lower():
+                        improved = cog_engine.improve_code(code, review)
+                        memory.add(session_id, "enhanced_code", improved)
+                        out = executor.execute_code(improved)
+                        results.append(f"🛠️ Enhanced code: {out}")
                     else:
-                        results.append(f"✅ Code executed successfully:\\n{execution_result}")
-                
-                elif "diagnose" in step.lower() or "check" in step.lower():
-                    # Self-diagnostic
+                        results.append(f"✅ Code executed: {out}")
+                elif key in ["diagnose", "check"]:
                     issues = cog_engine.identify_improvements(step)
                     memory.add(session_id, "diagnosis", issues)
-                    
                     if issues:
                         fixes = cog_engine.generate_enhancements(issues)
                         cog_engine.apply_enhancements(fixes)
-                        results.append(f"⚙️ System repaired: {', '.join(issues)}")
+                        results.append(f"⚙️ Repaired: {', '.join(issues)}")
                     else:
-                        results.append("✅ System health check passed")
+                        results.append("✅ Healthy")
             
             self.state["sessions"][session_id]["status"] = "completed"
             self.save_state()
-            snapshot_url = packager.create_snapshot({
-                "session_id": session_id,
-                "memory": memory.get(session_id),
-                "results": results
-            })
-            return "\\n\\n".join(results), session_id, snapshot_url
-        
+            snap = packager.create_snapshot({"session_id": session_id, "memory": memory.get(session_id), "results": results})
+            return "\n\n".join(results), session_id, snap
         except Exception as e:
-            logging.error(f"Error processing goal: {str(e)}", exc_info=True)
-            # Attempt self-repair
-            issues = [f"Runtime error: {str(e)}"]
+            logging.error(f"Error: {e}", exc_info=True)
+            issues = [str(e)]
             fixes = cog_engine.generate_enhancements(issues)
             cog_engine.apply_enhancements(fixes)
-            return f"⚠️ Error occurred. Self-repair initiated: {str(e)}", session_id, ""
+            return f"⚠️ Error occurred: {e}", session_id, ""
 
-# Initialize the agent
 agent = AutonomousAgent()
 
-# Create the Gradio interface
 with gr.Blocks(css="style.css", title="Autonomous AI") as demo:
-    session_id = gr.State()
-    learning_session = gr.State({"history": []})
-    
+    sid = gr.State()
+    hist = gr.State({"history": []})
     gr.Markdown("# 🤖 Autonomous AI System")
-    
     with gr.Tab("Task Execution"):
-        gr.Markdown("## 🚀 Execute Autonomous Tasks")
-        gr.Markdown("Enter a goal and the AI will research, plan, code, and self-improve to accomplish it.")
-        
-        with gr.Row():
-            goal_input = gr.Textbox(label="Your Goal", placeholder="Enter what you want to achieve...")
-            submit_btn = gr.Button("Execute Goal", variant="primary")
-        
-        output = gr.Textbox(label="Execution Results", interactive=False, lines=10)
-        session_display = gr.Textbox(label="Session ID", interactive=False)
-        snapshot = gr.Textbox(label="Snapshot URL", interactive=False)
-        
-        submit_btn.click(
-            fn=agent.process_goal,
-            inputs=[goal_input, session_id],
-            outputs=[output, session_display, snapshot]
-        )
-    
+        inp = gr.Textbox(label="Your Goal")
+        btn = gr.Button("Execute Goal")
+        out = gr.Textbox(label="Results", lines=10)
+        sid_box = gr.Textbox(label="Session ID")
+        snap_box = gr.Textbox(label="Snapshot URL")
+        btn.click(agent.process_goal, [inp, sid], [out, sid_box, snap_box])
     with gr.Tab("Learning Coach"):
-        gr.Markdown("## 🎓 Personalized Learning Assistant")
-        gr.Markdown("Ask about any topic and I'll provide curated knowledge from reliable sources!")
-        
-        with gr.Row():
-            with gr.Column(scale=3):
-                learning_chat = gr.Chatbot(label="Learning Conversation", height=400)
-                learning_input = gr.Textbox(label="Your Question", placeholder="Ask about any topic...")
-                
-                with gr.Row():
-                    submit_question = gr.Button("Ask", variant="primary")
-                    clear_chat = gr.Button("Clear Conversation")
-            
-            with gr.Column(scale=2):
-                knowledge_display = gr.Markdown("## Knowledge Resources\\n\\n*Your learning resources will appear here*")
-                level_buttons = gr.Radio(
-                    ["Beginner", "Intermediate", "Advanced"],
-                    label="Knowledge Level",
-                    value="Beginner"
-                )
-                feedback = gr.Textbox(label="Feedback", placeholder="Too basic/advanced? Want more depth?")
-                submit_feedback = gr.Button("Submit Feedback")
-    
-    # Learning Coach event handlers
-    def ask_question(question, history, session):
-        if not question.strip():
-            return history, session, "Please enter a question"
-        
-        # Get response from cognitive engine
-        response = cog_engine.learning_coach_response(question)
-        
-        # Update history
-        new_entry = (question, response)
-        history.append(new_entry)
-        
-        # Get knowledge display
-        knowledge_html = response if response.startswith("##") else "## 📚 Knowledge Resources\\n\\n" + response
-        
-        return history, session, knowledge_html
-    
-    def update_learning_level(level, session):
-        cog_engine.learning_context["level"] = level.lower()
-        return session
-    
-    def process_feedback(feedback_text, session):
-        if feedback_text.strip():
-            cog_engine.update_learning_context(feedback_text)
-        return "Feedback received! I'll adjust my teaching approach.", session
-    
-    def clear_conversation(session):
-        cog_engine.conversation_history = []
-        cog_engine.learning_context = {"level": "beginner"}
-        return [], session, "## Knowledge Resources\\n\\n*Conversation cleared*"
-    
-    # Connect components
-    submit_question.click(
-        ask_question,
-        [learning_input, learning_chat, learning_session],
-        [learning_chat, learning_session, knowledge_display]
-    )
-    
-    level_buttons.change(
-        update_learning_level,
-        [level_buttons, learning_session],
-        [learning_session]
-    )
-    
-    submit_feedback.click(
-        process_feedback,
-        [feedback, learning_session],
-        [feedback, learning_session]
-    )
-    
-    clear_chat.click(
-        clear_conversation,
-        [learning_session],
-        [learning_chat, learning_session, knowledge_display]
-    )
-    
-    # Allow submitting question with Enter key
-    learning_input.submit(
-        ask_question,
-        [learning_input, learning_chat, learning_session],
-        [learning_chat, learning_session, knowledge_display]
-    )
-
-if __name__ == "__main__":
-    demo.launch()
-""",
-        
-        "knowledge_integrator.py": """import requests
-import json
-import feedparser
-from datetime import datetime
-import re
-
-class KnowledgeIntegrator:
-    SOURCES = {
-        "openstax": {
-            "endpoint": "https://openstax.org/api/v2/pages",
-            "params": {"type": "textbook", "fields": "title,description,url"},
-            "parser": lambda data: [{
-                "title": item["title"],
-                "description": item["description"],
-                "url": item["url"]
-            } for item in data["items"]] if "items" in data else []
-        },
-        "arxiv": {
-            "endpoint": "http://export.arxiv.org/api/query",
-            "params": {"search_query": "", "start": 0, "max_results": 3},
-            "parser": lambda data: [{
-                "title": entry.title,
-                "summary": entry.summary,
-                "published": entry.published,
-                "url": entry.link
-            } for entry in data.entries] if hasattr(data, 'entries') else []
-        },
-        "wikimedia": {
-            "endpoint": "https://en.wikipedia.org/api/rest_v1/page/summary/",
-            "parser": lambda data: {
-                "summary": data["extract"],
-                "url": data["content_urls"]["desktop"]["page"]
-            } if "extract" in data else {}
-        },
-        "khanacademy": {
-            "endpoint": "https://www.khanacademy.org/api/v1/topic/",
-            "parser": lambda data: [{
-                "title": item["title"],
-                "description": item["description"],
-                "url": f"https://www.khanacademy.org{item['url']}"
-            } for item in data.get("children", []) if item["kind"] == "Video"]
-        }
-    }
-    
-    def __init__(self):
-        self.query_history = []
-    
-    def retrieve_knowledge(self, query, source_name):
-        source = self.SOURCES.get(source_name.lower())
-        if not source:
-            return {"error": "Invalid knowledge source"}
-        
-        try:
-            # Special handling for different API formats
-            if source_name == "wikimedia":
-                formatted_query = query.replace(" ", "_")
-                response = requests.get(source["endpoint"] + formatted_query)
-            elif source_name == "khanacademy":
-                response = requests.get(source["endpoint"] + query.lower())
-            else:
-                params = source["params"].copy()
-                params["search_query"] = query
-                response = requests.get(source["endpoint"], params=params)
-            
-            response.raise_for_status()
-            
-            # Parse based on content type
-            if 'json' in response.headers.get('Content-Type', ''):
-                data = response.json()
-            else:
-                # arXiv returns XML
-                data = feedparser.parse(response.text)
-            
-            return source["parser"](data)
-        except requests.exceptions.RequestException as e:
-            return {"error": f"Network error: {str(e)}"}
-        except Exception as e:
-            return {"error": f"Processing error: {str(e)}"}
-    
-    def integrate_in_teaching(self, concept, age_group="beginner", max_results=3):
-        \"\"\"Augment explanations with verified knowledge\"\"\"
-        # Get foundational knowledge
-        openstax_results = self.retrieve_knowledge(concept, "openstax")
-        khan_results = self.retrieve_knowledge(concept, "khanacademy")
-        
-        # Get current research
-        arxiv_results = self.retrieve_knowledge(concept, "arxiv")
-        
-        # Get quick reference
-        wiki_results = self.retrieve_knowledge(concept, "wikimedia")
-        
-        # Filter results based on age group
-        if age_group == "beginner":
-            arxiv_results = []  # Skip research for beginners
-        
-        # Format results
-        return {
-            "concept": concept,
-            "foundational": self._filter_results(openstax_results + khan_results, max_results),
-            "research": self._filter_results(arxiv_results, max_results),
-            "summary": wiki_results.get("summary", f"No summary available for {concept}"),
-            "summary_url": wiki_results.get("url", "")
-        }
-    
-    def _filter_results(self, results, max_results):
-        \"\"\"Filter out error responses and limit results\"\"\"
-        if isinstance(results, list):
-            return [item for item in results if not isinstance(item, dict) or "error" not in item][:max_results]
-        return results
-    
-    def format_for_display(self, knowledge_data):
-        \"\"\"Create user-friendly presentation of knowledge\"\"\"
-        if "error" in knowledge_data:
-            return knowledge_data["error"]
-        
-        response = f"## 📚 Learning Resources: {knowledge_data['concept']}\\n\\n"
-        
-        # Summary section
-        summary = knowledge_data['summary']
-        # Simplify complex sentences for beginners
-        if len(summary.split()) > 100:
-            summary = ". ".join(summary.split(". ")[:3]) + "."
-        response += f"**💡 Key Insights**\\n{summary}\\n"
-        if knowledge_data['summary_url']:
-            response += f"[Read more]({knowledge_data['summary_url']})\\n\\n"
-        
-        # Foundational knowledge
-        if knowledge_data['foundational']:
-            response += "**📖 Foundational Knowledge**\\n"
-            for item in knowledge_data['foundational']:
-                title = item.get('title', 'Untitled Resource')
-                desc = item.get('description', 'No description available')
-                url = item.get('url', '#')
-                response += f"- [{title}]({url}): {desc[:150]}...\\n"
-            response += "\\n"
-        
-        # Research frontier
-        if knowledge_data['research']:
-            response += "**🔬 Current Research**\\n"
-            for item in knowledge_data['research']:
-                title = item.get('title', 'Untitled Paper')
-                published = item.get('published', '')
-                if published:
-                    try:
-                        pub_date = datetime.strptime(published, '%Y-%m-%dT%H:%M:%SZ')
-                        published = pub_date.strftime('%b %Y')
-                    except:
-                        pass
-                url = item.get('url', '#')
-                response += f"- [{title}]({url})"
-                if published:
-                    response += f" ({published})"
-                response += "\\n"
-        
-        response += "\\n**Which area would you like to explore further?**"
-        return response
-    
-    def extract_concept(self, user_input):
-        \"\"\"Extract the main concept from user input\"\"\"
-        # Simple extraction: look for key phrases
-        patterns = [
-            r"explain (.*)",
-            r"what is (.*)\\?",
-            r"tell me about (.*)",
-            r"how does (.*) work\\?",
-            r"teach me (.*)"
-        ]
-        
-        for pattern in patterns:
-            match = re.search(pattern, user_input, re.IGNORECASE)
-            if match:
-                concept = match.group(1).strip()
-                # Remove trailing question words
-                concept = re.sub(r"\\?$", "", concept)
-                return concept
-        
-        # Fallback: return the first 3 words
-        return " ".join(user_input.split()[:3])
-""",
-        
-        "cognitive_engine.py": """import random
-import os
-from knowledge_integrator import KnowledgeIntegrator
-
-class CognitiveEngine:
-    def __init__(self):
-        self.knowledge = KnowledgeIntegrator()
-        self.learning_context = {"level": "beginner"}
-        self.conversation_history = []
-    
-    def identify_improvements(self, task):
-        issues = []
-        if random.random() > 0.7:
-            issues.append("Memory optimization")
-        if random.random() > 0.8:
-            issues.append("Error handling enhancement")
-        if "search" in task:
-            issues.append("Information retrieval accuracy")
-        return issues
-    
-    def generate_enhancements(self, targets):
-        enhancements = []
-        for target in targets:
-            if "memory" in target.lower():
-                enhancements.append("Optimized memory usage with caching")
-            elif "error" in target.lower():
-                enhancements.append("Added comprehensive error handling")
-            elif "retrieval" in target.lower():
-                enhancements.append("Improved search relevance algorithms")
-        return enhancements
-    
-    def apply_enhancements(self, enhancements):
-        print(f"Applying enhancements: {enhancements}")
-        with open("log.txt", "a") as log_file:
-            log_file.write(f"System enhancements applied: {enhancements}\\n")
-        return True
-    
-    def generate_code(self, task, context):
-        return f'''# Generated code for: {task}
-import requests
-
-def main():
-    \"\"\"Autonomously generated function\"\"\"
-    print("Hello from AI-generated code!")
-    print(f"Task context: {str(context)[:100]}...")
-    
-    # TODO: Implement actual functionality
-    return "Task completed successfully"
-
-if __name__ == "__main__":
-    main()
-'''
-    
-    def improve_code(self, code, review):
-        return f'''# Improved code based on review: "{review}"
-{code}
-
-# Added error handling based on review
-try:
-    # Existing implementation
-    pass
-except Exception as e:
-    print(f"Error occurred: {{str(e)}}")
-    # Additional error recovery logic
-'''
-    
-    def learning_coach_response(self, user_query, session_id=None):
-        \"\"\"Generate educational response with integrated knowledge\"\"\"
-        # Update conversation history
-        self.conversation_history.append({"role": "user", "content": user_query})
-        
-        # Extract core concept
-        concept = self.knowledge.extract_concept(user_query)
-        if not self.learning_context.get("core_concept"):
-            self.learning_context["core_concept"] = concept
-        
-        # Refine context based on conversation
-        if "explain" in user_query.lower() or "what is" in user_query.lower():
-            self.learning_context["level"] = "beginner"
-        elif "research" in user_query.lower() or "latest" in user_query.lower():
-            self.learning_context["level"] = "advanced"
-        
-        # Retrieve and integrate knowledge
-        knowledge = self.knowledge.integrate_in_teaching(
-            self.learning_context["core_concept"],
-            age_group=self.learning_context["level"]
-        )
-        
-        # Format response
-        response = self.knowledge.format_for_display(knowledge)
-        
-        # Update conversation history
-        self.conversation_history.append({"role": "assistant", "content": response})
-        
-        return response
-    
-    def update_learning_context(self, user_feedback):
-        \"\"\"Refine teaching approach based on user interaction\"\"\"
-        if "too basic" in user_feedback.lower():
-            self.learning_context["level"] = "advanced"
-        elif "too advanced" in user_feedback.lower():
-            self.learning_context["level"] = "beginner"
-        elif "related to" in user_feedback.lower():
-            # Extract new concept from feedback
-            new_concept = user_feedback.split("related to")[-1].strip()
-            self.learning_context["core_concept"] = new_concept
-        elif "change topic" in user_feedback.lower():
-            # Reset context for new topic
-            self.learning_context = {"level": "beginner"}
-            
-        return "Thank you for your feedback! I'll adjust my teaching approach."
-""",
-        
-        "memory.py": """import json
-import os
-from datetime import datetime
-
-class MemoryManager:
-    def __init__(self):
-        self.file_path = "memory.json"
-        self.memory = self.load_memory()
-    
-    def load_memory(self):
-        if os.path.exists(self.file_path):
-            try:
-                with open(self.file_path, 'r') as f:
-                    return json.load(f)
-            except json.JSONDecodeError:
-                return {}
-        return {}
-    
-    def save_memory(self):
-        with open(self.file_path, 'w') as f:
-            json.dump(self.memory, f, indent=2)
-    
-    def init_session(self, session_id):
-        if session_id not in self.memory:
-            self.memory[session_id] = {
-                "created": datetime.now().isoformat(),
-                "entries": []
-            }
-            self.save_memory()
-    
-    def add(self, session_id, key, value):
-        if session_id in self.memory:
-            self.memory[session_id]["entries"].append({
-                "timestamp": datetime.now().isoformat(),
-                "key": key,
-                "value": value
-            })
-            self.save_memory()
-    
-    def get(self, session_id):
-        return self.memory.get(session_id, {"entries": []})
-    
-    def search(self, session_id, query):
-        results = []
-        for entry in self.get(session_id)["entries"]:
-            if (query.lower() in entry["key"].lower() or 
-                (isinstance(entry["value"], str) and query.lower() in entry["value"].lower()):
-                results.append(entry)
-        return results
-    
-    def get_summary(self, session_id):
-        entries = self.get(session_id)["entries"]
-        if not entries:
-            return "No memories found"
-        
-        # Create a summary of key events
-        summary = [f"Session started at {entries[0]['timestamp']}"]
-        for entry in entries[-5:]:  # Last 5 entries
-            summary.append(f"{entry['timestamp']}: {entry['key']}")
-        return "\\n".join(summary)
-""",
-        
-        "planner.py": """import random
-
-class Planner:
-    def plan_task(self, goal, memory):
-        plan = [
-            f"Research: Search web for information about {goal}",
-            f"Learn: Analyze search results to understand {goal}",
-            f"Develop: Generate code to accomplish {goal}",
-            f"Execute: Run the generated code",
-            f"Diagnose: Check system health and performance",
-            f"Review: Evaluate results and identify improvements"
-        ]
-        
-        # Add additional steps based on goal complexity
-        if len(goal) > 50 or "complex" in goal.lower():
-            plan.insert(2, "Design: Create architecture for solution")
-            plan.insert(4, "Implement: Build core functionality")
-        
-        return plan
-""",
-        
-        "executor.py": """import subprocess
-import os
-import tempfile
-
-class Executor:
-    def execute_code(self, code):
-        try:
-            # Save code to temporary file
-            with tempfile.NamedTemporaryFile(suffix=".py", delete=False, mode="w") as temp_file:
-                temp_file.write(code)
-                temp_file_path = temp_file.name
-            
-            # Execute the code
-            result = subprocess.run(
-                ["python", temp_file_path],
-                capture_output=True,
-                text=True,
-                timeout=30
-            )
-            
-            # Clean up
-            os.unlink(temp_file_path)
-            
-            if result.returncode == 0:
-                return result.stdout.strip() or "Code executed successfully"
-            else:
-                return f"Error: {result.stderr.strip() or 'Unknown error'}"
-        
-        except subprocess.TimeoutExpired:
-            return "Error: Code execution timed out"
-        except Exception as e:
-            return f"Execution error: {str(e)}"
-""",
-        
-        "critic.py": """import random
-
-class Critic:
-    def review(self, step, result):
-        reviews = {
-            "code": [
-                "Code executed successfully with no errors.",
-                "Code executed but produced unexpected output.",
-                "Code contains inefficiencies that could be optimized.",
-                "Excellent implementation following best practices."
-            ],
-            "search": [
-                "Relevant information found for the task.",
-                "Search results could be more targeted.",
-                "Comprehensive research completed successfully."
-            ],
-            "diagnose": [
-                "System health check completed with no issues found.",
-                "Minor optimizations identified for system performance.",
-                "Critical improvements needed in error handling."
-            ]
-        }
-        
-        if "code" in step.lower() or "develop" in step.lower():
-            return random.choice(reviews["code"])
-        elif "research" in step.lower() or "search" in step.lower():
-            return random.choice(reviews["search"])
-        elif "diagnose" in step.lower() or "check" in step.lower():
-            return random.choice(reviews["diagnose"])
-        return "Step completed adequately."
-""",
-        
-        "web_searcher.py": """from duckduckgo_search import DDGS
-import json
-
-class WebSearcher:
-    def search(self, query, max_results=5):
-        try:
-            with DDGS() as ddgs:
-                results = [r for r in ddgs.text(query, max_results=max_results)]
-                return json.dumps(results, indent=2)
-        except Exception as e:
-            return f"Search error: {str(e)}"
-""",
-        
-        "hf_packager.py": """import uuid
-import json
-from datetime import datetime
-import os
-
-class HFSpacePackager:
-    def create_snapshot(self, data=None):
-        snapshot_id = str(uuid.uuid4())
-        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-        filename = f"snapshots/snapshot_{timestamp}_{snapshot_id[:8]}.json"
-        
-        # Save snapshot to file
-        os.makedirs("snapshots", exist_ok=True)
-        with open(filename, "w") as f:
-            json.dump(data, f, indent=2)
-        
-        return f"https://huggingface.co/spaces/Leonydis137/Autonomous-AI/snapshots?file={filename}"
-""",
-        
-        "style.css": """body {
-    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-    background: linear-gradient(135deg, #1a2a6c, #b21f1f, #fdbb2d);
-    color: #333;
-    margin: 0;
-    padding: 20px;
-    min-height: 100vh;
-}
-
-.container {
-    max-width: 1200px;
-    margin: 0 auto;
-    background: rgba(255, 255, 255, 0.95);
-    border-radius: 15px;
-    box-shadow: 0 10px 30px rgba(0, 0, 0, 0.2);
-    padding: 30px;
-}
-
-h1, h2, h3 {
-    color: #2c3e50;
-}
-
-h1 {
-    text-align: center;
-    margin-bottom: 30px;
-    font-size: 2.5rem;
-    text-shadow: 1px 1px 3px rgba(0,0,0,0.1);
-}
-
-.tab {
-    padding: 20px;
-    border-radius: 10px;
-    background: rgba(255, 255, 255, 0.85);
-    margin-top: 15px;
-}
-
-.input-group {
-    margin-bottom: 25px;
-}
-
-textarea, input[type="text"] {
-    width: 100%;
-    padding: 15px;
-    border: 2px solid #3498db;
-    border-radius: 10px;
-    font-size: 1.1rem;
-    transition: border-color 0.3s;
-    background: white;
-}
-
-textarea:focus, input[type="text"]:focus {
-    border-color: #e74c3c;
-    outline: none;
-    box-shadow: 0 0 10px rgba(231, 76, 60, 0.3);
-}
-
-button {
-    background: #3498db;
-    color: white;
-    border: none;
-    padding: 15px 25px;
-    font-size: 1.1rem;
-    border-radius: 10px;
-    cursor: pointer;
-    transition: all 0.3s;
-    font-weight: bold;
-    margin: 10px 5px;
-}
-
-button:hover {
-    background: #2980b9;
-    transform: translateY(-3px);
-    box-shadow: 0 5px 15px rgba(0,0,0,0.2);
-}
-
-.btn-primary {
-    background: #e74c3c;
-}
-
-.btn-primary:hover {
-    background: #c0392b;
-}
-
-.output-section {
-    background: #f8f9fa;
-    border-radius: 10px;
-    padding: 20px;
-    margin-top: 20px;
-    border-left: 5px solid #3498db;
-}
-
-.chat-container {
-    background: white;
-    border-radius: 10px;
-    padding: 15px;
-    box-shadow: 0 4px 6px rgba(0,0,0,0.1);
-    max-height: 500px;
-    overflow-y: auto;
-}
-
-.chat-message {
-    margin: 10px 0;
-    padding: 10px 15px;
-    border-radius: 15px;
-    max-width: 80%;
-}
-
-.user-message {
-    background: #e3f2fd;
-    margin-left: auto;
-    border-bottom-right-radius: 5px;
-}
-
-.bot-message {
-    background: #f5f5f5;
-    margin-right: auto;
-    border-bottom-left-radius: 5px;
-}
-
-.knowledge-panel {
-    background: #fffde7;
-    border-radius: 10px;
-    padding: 15px;
-    margin-top: 15px;
-    border: 1px solid #ffecb3;
-}
-
-.knowledge-panel h3 {
-    color: #ff9800;
-    margin-top: 0;
-    border-bottom: 2px solid #ffecb3;
-    padding-bottom: 8px;
-}
-
-.resource-list {
-    list-style-type: none;
-    padding: 0;
-}
-
-.resource-list li {
-    margin-bottom: 10px;
-    padding: 8px;
-    background: white;
-    border-radius: 8px;
-    border-left: 3px solid #3498db;
-}
-
-.resource-link {
-    color: #2980b9;
-    text-decoration: none;
-    font-weight: bold;
-}
-
-.resource-link:hover {
-    text-decoration: underline;
-}
-""",
-        
-        "requirements.txt": """duckduckgo-search
-gradio
-requests
-python-dotenv
-feedparser
-""",
-        
-        "README.md": """# Autonomous AI System
-
-This is a self-improving AI system that can:
-- Search the web for information
-- Learn from new information
-- Generate and execute its own code
-- Diagnose and repair itself
-- Continuously improve its capabilities
-
-## Features
-
-1. **Goal-Oriented Processing**  
-   Enter any goal and the AI will create a plan to achieve it
-
-2. **Web Search Integration**  
-   Uses DuckDuckGo to research topics and gather information
-
-3. **Self-Coding Capability**  
-   Generates Python code to solve problems and executes it safely
-
-4. **Self-Diagnostic System**  
-   Regularly checks its own performance and identifies improvements
-
-5. **Continuous Learning**  
-   Maintains memory of all sessions for context-aware operations
-
-6. **Self-Repair Mechanism**  
-   Automatically fixes identified issues in its own systems
-
-7. **Learning Coach**  
-   Provides personalized education using vetted knowledge sources
-
-8. **Snapshot System**  
-   Creates recoverable snapshots of system state
-
-## Setup Instructions
-
-1. Install Python 3.8 or higher
-
-2. Install requirements:
-```bash
-pip install -r requirements.txt
+        chat = gr.Chatbot()
+        q_in = gr.Textbox(label="Your Question")
+        ask = gr.Button("Ask")
+        clear = gr.Button("Clear")
+        kb = gr.Markdown("")
+        ask.click(lambda q,h: (h+[(q, cog_engine.learning_coach_response(q))], h), [q_in, hist], [chat, hist])
+        clear.click(lambda h: ([],h), [hist], [chat, hist])
+
+demo.launch()