Update app.py

app.py

@@ -21,4 +21,317 @@ gr.mount_gradio_app(app, gr_interface, path="/gradio")
 
 @app.get("/")
 def root():
-    return {"message": "Multi-Agent AI system with logging and memory."}
+    return {"message": "Multi-Agent AI system with logging and memory."}
+''',
+
+from src.core.cognitive_engine import CognitiveEngine
+from src.utils.hf_packager import HFSpacePackager
+import gradio as gr
+import time
+import os
+import psutil
+import json
+
+# Initialize components
+cognitive_engine = CognitiveEngine()
+packager = HFSpacePackager()
+
+# Load knowledge base
+def load_knowledge():
+    try:
+        with open("knowledge/state.json", "r") as f:
+            return json.load(f)
+    except:
+        return {"improvements": [], "solutions": {}, "tasks": []}
+
+# Save knowledge base
+def save_knowledge(data):
+    with open("knowledge/state.json", "w") as f:
+        json.dump(data, f, indent=2)
+
+# Main autonomous cycle
+def run_cycle(task_description):
+    knowledge = load_knowledge()
+    knowledge["tasks"].append(task_description)
+    save_knowledge(knowledge)
+    
+    try:
+        improvement_targets = cognitive_engine.identify_improvements(task_description)
+        code_updates = cognitive_engine.generate_enhancements(improvement_targets)
+        
+        if cognitive_engine.apply_enhancements(code_updates):
+            snapshot_url = packager.create_snapshot()
+            return (
+                f"✅ Task completed! Snapshot: {snapshot_url}",
+                code_updates,
+                "\n".join(improvement_targets)
+            )
+        return (
+            "❌ Improvement failed - see logs",
+            "",
+            ""
+        )
+    except Exception as e:
+        return (
+            f"⚠️ Critical error: {str(e)}",
+            "",
+            ""
+        )
+
+# Get system resources
+def get_resource_usage():
+    return {
+        "cpu": f"{psutil.cpu_percent()}%",
+        "memory": f"{psutil.virtual_memory().percent}%",
+        "disk": f"{psutil.disk_usage('/').percent}%"
+    }
+
+# Get task history
+def get_task_history():
+    knowledge = load_knowledge()
+    return "\n".join([f"- {task}" for task in knowledge["tasks"][-5:]])
+
+# Manual code submission
+def submit_manual_code(code):
+    try:
+        if cognitive_engine.apply_enhancements(code):
+            snapshot_url = packager.create_snapshot()
+            return f"✅ Code applied! Snapshot: {snapshot_url}", code
+        return "❌ Code application failed", code
+    except Exception as e:
+        return f"⚠️ Error: {str(e)}", code
+
+with gr.Blocks(css="static/style.css", theme=gr.themes.Soft()) as demo:
+    knowledge = load_knowledge()
+    
+    gr.Markdown("# 🤖 Interactive Autonomous AI System")
+    
+    with gr.Tab("Task-Based Improvement"):
+        with gr.Row():
+            with gr.Column():
+                task_input = gr.Textbox(
+                    label="Describe your improvement task",
+                    placeholder="e.g., 'Optimize the validation system' or 'Add user authentication'",
+                    lines=3
+                )
+                submit_task = gr.Button("🚀 Execute Task", variant="primary")
+                
+                gr.Markdown("### System Resources")
+                resource_display = gr.JSON(value=get_resource_usage(), label="Current Status")
+                refresh_btn = gr.Button("🔄 Refresh Status")
+                
+            with gr.Column():
+                task_output = gr.Textbox(label="Task Status", interactive=False)
+                improvement_list = gr.Textbox(label="Identified Improvements", interactive=False)
+                generated_code = gr.Code(
+                    label="Generated Code",
+                    language="python",
+                    interactive=True
+                )
+    
+    with gr.Tab("Manual Code Submission"):
+        with gr.Row():
+            with gr.Column():
+                manual_code = gr.Code(
+                    label="Submit Your Own Code",
+                    language="python",
+                    value="# Write your code enhancements here",
+                    interactive=True
+                )
+                submit_manual = gr.Button("💾 Apply Code", variant="primary")
+                manual_output = gr.Textbox(label="Result")
+            with gr.Column():
+                gr.Markdown("### Code Guidelines")
+                gr.Markdown("""
+                1. Ensure backward compatibility
+                2. Include necessary imports
+                3. Add comments explaining changes
+                4. Avoid system-critical modifications
+                """)
+    
+    with gr.Tab("Knowledge & History"):
+        task_history = gr.Textbox(
+            label="Recent Tasks",
+            value=get_task_history(),
+            interactive=False
+        )
+        gr.Markdown("### Improvement Database")
+        knowledge_display = gr.JSON(
+            value={k: v for k, v in knowledge.items() if k != "solutions"},
+            label="System Knowledge"
+        )
+        refresh_knowledge = gr.Button("🔁 Refresh Knowledge")
+    
+    # Task submission
+    submit_task.click(
+        run_cycle,
+        inputs=[task_input],
+        outputs=[task_output, generated_code, improvement_list]
+    )
+    
+    # Manual code submission
+    submit_manual.click(
+        submit_manual_code,
+        inputs=[manual_code],
+        outputs=[manual_output, manual_code]
+    )
+    
+    # Refresh actions
+    refresh_btn.click(
+        get_resource_usage,
+        inputs=[],
+        outputs=resource_display
+    )
+    
+    refresh_knowledge.click(
+        lambda: load_knowledge(),
+        inputs=[],
+        outputs=knowledge_display
+    )
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_api=True
+    )
+
+    "orchestrator.py": '''
+from agents.planner import plan_task
+from agents.executor import execute_step
+from agents.critic import review_result
+from memory import add_to_memory, search_memory
+import uuid
+from datetime import datetime
+
+def run_agents(goal, memory, session_id=None):
+    session_id = session_id or str(uuid.uuid4())[:8]
+    timestamp = datetime.now().isoformat(timespec="seconds")
+
+    log = f"[{timestamp}] Session {session_id}: Goal: {goal}\\n"
+    history = search_memory(goal, memory)
+    context = "\\n".join(history[:3]) if history else "No relevant memory found."
+
+    plan = plan_task(goal, memory)
+    add_to_memory(f"[{session_id}] 🧠 Context: {context}", memory)
+    add_to_memory(f"[{session_id}] 🗂 Plan: {plan}", memory)
+
+    outputs = []
+    for step in plan:
+        result = execute_step(step)
+        add_to_memory(f"[{session_id}] 🔧 Executor ran: {step} -> {result}", memory)
+
+        review = review_result(step, result)
+        add_to_memory(f"[{session_id}] 🔍 Critic: {review}", memory)
+
+        step_log = f"🔹 Step: {step}\\n🛠 Result: {result}\\n🧠 Review: {review}\\n"
+        log += step_log + "\\n"
+        outputs.append(step_log)
+
+    with open("log.txt", "a") as f:
+        f.write(log + "\\n")
+
+    return "\\n".join(outputs)
+''',
+
+    "memory.py": '''
+from sentence_transformers import SentenceTransformer
+import numpy as np
+import faiss
+import json
+import os
+
+model = SentenceTransformer("all-MiniLM-L6-v2")
+MEMORY_LOG = "memory_log.json"
+
+def init_memory():
+    dim = 384
+    index = faiss.IndexFlatL2(dim)
+    memory = {"index": index, "texts": []}
+    if os.path.exists(MEMORY_LOG):
+        with open(MEMORY_LOG, "r") as f:
+            memory["texts"] = json.load(f)
+        vectors = np.array([model.encode([text])[0] for text in memory["texts"]])
+        if len(vectors) > 0:
+            memory["index"].add(vectors)
+    return memory
+
+def add_to_memory(text, memory):
+    vec = model.encode([text])[0]
+    memory["index"].add(np.array([vec]))
+    memory["texts"].append(text)
+    with open(MEMORY_LOG, "w") as f:
+        json.dump(memory["texts"], f)
+
+def search_memory(query, memory, k=5):
+    vec = model.encode([query])[0]
+    D, I = memory["index"].search(np.array([vec]), k)
+    return [memory["texts"][i] for i in I[0] if i < len(memory["texts"])]
+''',
+
+    "agents/planner.py": '''
+def plan_task(goal, memory):
+    plan = []
+    if "website" in goal:
+        plan.extend([
+            "Create basic HTML structure",
+            "Add styling with CSS",
+            "Add interactivity with JavaScript",
+            "Review and test website"
+        ])
+    else:
+        plan.extend([
+            f"Understand the goal: {goal}",
+            "Find the best method to solve it",
+            "Execute and gather result"
+        ])
+    return plan
+''',
+
+    "agents/executor.py": '''
+import subprocess
+
+def execute_step(step):
+    step_lower = step.lower()
+    if "html" in step_lower:
+        return "<html><body>Hello Multi-Agent World!</body></html>"
+    elif "calculate" in step_lower:
+        try:
+            expression = step_lower.replace("calculate", "").strip()
+            return str(eval(expression))
+        except:
+            return "Calculation error."
+    elif "python" in step_lower or "code" in step_lower:
+        try:
+            code = step.split("```python")[1].split("```")[0] if "```python" in step else step
+            result = subprocess.check_output(["python3", "-c", code], stderr=subprocess.STDOUT, timeout=5)
+            return result.decode()
+        except Exception as e:
+            return f"Error running Python code: {e}"
+    else:
+        return f"No defined execution path for: {step}"
+''',
+
+    "agents/critic.py": '''
+def review_result(step, result):
+    if not result or "error" in result.lower():
+        return f"❌ Step failed or incomplete: {step}. Result: {result[:80]}"
+    if len(result) < 10:
+        return f"⚠️ Result seems too short for step: {step}."
+    return f"✅ Step successful. Result preview: {result[:80]}"
+''',
+
+    "requirements.txt": '''
+fastapi
+uvicorn
+gradio
+faiss-cpu
+sentence-transformers
+numpy
+''',
+
+    ".huggingface.yaml": '''
+sdk: gradio
+sdk_version: 3.50.2
+app_file: app.py
+''',