Update app.py

app.py

@@ -4,23 +4,55 @@ import gradio as gr
 import time
 import os
 import psutil
+import json
 
 # Initialize components
 cognitive_engine = CognitiveEngine()
 packager = HFSpacePackager()
 
-def run_cycle():
+# Load knowledge base
+def load_knowledge():
     try:
-        improvement_targets = cognitive_engine.identify_improvements()
+        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"✅ Cycle complete! Snapshot: {snapshot_url}"
-        return "❌ Improvement failed - see logs"
+            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)}"
+        return (
+            f"⚠️ Critical error: {str(e)}",
+            "",
+            ""
+        )
 
+# Get system resources
 def get_resource_usage():
     return {
         "cpu": f"{psutil.cpu_percent()}%",
@@ -28,31 +60,107 @@ def get_resource_usage():
         "disk": f"{psutil.disk_usage('/').percent}%"
     }
 
-def update_resources():
-    return get_resource_usage()
+# Get task history
+def get_task_history():
+    knowledge = load_knowledge()
+    return "\n".join([f"- {task}" for task in knowledge["tasks"][-5:]])
 
-with gr.Blocks(css="static/style.css", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🤖 Autonomous AI System")
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            start_btn = gr.Button("🚀 Start Improvement Cycle", variant="primary")
-            status = gr.Textbox(label="Status", interactive=False)
-            
-            gr.Markdown("### System Resources")
-            resource_display = gr.JSON(label="Current Usage", value=get_resource_usage())
-            
-            # Manual refresh button
-            refresh_btn = gr.Button("🔄 Refresh Resources")
-            refresh_btn.click(update_resources, outputs=resource_display)
-        
-        with gr.Column(scale=2):
-            gr.HTML(open("templates/dashboard.html", "r").read())
+# 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
 
-    start_btn.click(
+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=status
+        outputs=knowledge_display
     )
 
 if __name__ == "__main__":