Upload 7 files

README.md

@@ -1,23 +1,25 @@
----
-title: Autonomous AI
-emoji: 🤖
-colorFrom: gray
-colorTo: green
-sdk: gradio
-sdk_version: "3.41.0"
-app_file: app.py
-pinned: false
----
-# 🤖 Autonomous AI (HF Space Template)
-
-This is a proof-of-concept **autonomous AI agent** that:
-- Takes a user-defined task
-- Plans and writes code to complete it
-- Executes and displays results
-- Designed to self-debug and improve over time
-
-## How It Works
-
-- Built with `gradio`
-- Task sent to `agent.py` which plans + generates Python code
-- Output printed in a chatbot-style UI
+
+# 🤖 Autonomous AI — Fully Self-Updating Python Agent
+
+This is a powerful, self-improving autonomous agent capable of:
+
+- Planning tasks
+- Writing and executing Python code
+- Debugging itself
+- Storing memory and logs
+- Growing over time
+
+## Files
+
+- `app.py`: Gradio UI
+- `agent.py`: Core self-runner
+- `utils.py`: Task planning, logging, memory
+- `memory.txt`: Long-term task memory
+- `logs/`: JSON logs of each run
+
+## Usage
+
+1. Upload to [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Set type to `Gradio`
+3. Enjoy your AI developer assistant
+

agent.py

@@ -1,11 +1,24 @@
 
+import os
 import traceback
+from datetime import datetime
+from utils import save_log, read_memory, write_memory, plan_task, generate_code, run_code
 
-def run_autonomous_loop(task):
+MEMORY_FILE = "memory.txt"
+LOG_DIR = "logs"
+
+def autonomous_agent(task):
     try:
-        plan = f"Planning how to: {task}"
-        code = f"# Code generated to: {task}\nprint('Task done: {task}')"
-        exec(code, {})
-        return f"✅ Success. Plan: {plan}\n\n{code}"
+        plan = plan_task(task)
+        code = generate_code(task)
+        result = run_code(code)
+
+        # Save memory and logs
+        write_memory(f"{datetime.now()}: Completed task '{task}'")
+        save_log(task, plan, code, result)
+
+        return f"✅ Task Complete:\nPlan: {plan}\n\nCode:\n{code}\n\nResult:\n{result}"
     except Exception as e:
-        return f"❌ Failed: {str(e)}\n\nTraceback:\n{traceback.format_exc()}"
+        error = traceback.format_exc()
+        save_log(task, "FAILED", "None", error)
+        return f"❌ Task Failed:\n{error}"

agent_editor.py

@@ -0,0 +1,12 @@
+
+def update_agent_code(new_code):
+    with open("agent.py", "w") as f:
+        f.write(new_code)
+    return "✅ agent.py updated. Rebuild or reload your Space to apply changes."
+
+def read_agent_code():
+    try:
+        with open("agent.py", "r") as f:
+            return f.read()
+    except FileNotFoundError:
+        return "# agent.py not found"

app.py

@@ -1,17 +1,96 @@
 
 import gradio as gr
-from agent import run_autonomous_loop
+from agent import autonomous_agent
+from utils import read_memory, append_feedback
+from agent_editor import update_agent_code, read_agent_code
+import threading, time
+
+current_task = ""
+loop_running = False
+
+def run_task(task):
+    global current_task
+    current_task = task
+    result = autonomous_agent(task)
+    return result, read_memory()
+
+def update_memory(new_text):
+    with open("memory.txt", "w") as f:
+        f.write(new_text)
+    return "✅ Memory updated."
+
+def view_logs():
+    import os, json
+    log_entries = []
+    if not os.path.exists("logs"):
+        return "No logs yet."
+    for filename in sorted(os.listdir("logs"))[-5:]:
+        with open(f"logs/{filename}", "r") as f:
+            data = json.load(f)
+            log_entries.append(f"🕒 {data['timestamp']}\n🔧 Task: {data['task']}\n✅ Result: {data['result'][:100]}...\n---")
+    return "\n\n".join(log_entries) if log_entries else "No logs found."
+
+def store_feedback(score):
+    append_feedback(current_task, "See logs for result", score)
+    return "✅ Feedback stored."
+
+def toggle_loop(toggle: bool, interval: int = 30):
+    global loop_running
+    loop_running = toggle
+    if toggle:
+        thread = threading.Thread(target=loop_runner, args=(interval,), daemon=True)
+        thread.start()
+        return "🔁 Loop started."
+    else:
+        return "⏹️ Loop stopped."
+
+def loop_runner(interval):
+    global loop_running
+    while loop_running:
+        run_task("Autonomous self-improvement")
+        time.sleep(interval)
 
 with gr.Blocks() as demo:
-    gr.Markdown("# 🤖 Autonomous AI: Self-Improving Agent")
-    chatbot = gr.Chatbot()
-    user_input = gr.Textbox(label="What should the AI work on?")
-    button = gr.Button("Execute Task")
+    gr.Markdown("# 🤖 Autonomous AI Agent — Enhanced")
+
+    with gr.Tab("💬 Task Runner"):
+        chatbot = gr.Textbox(lines=2, label="What should the AI do?")
+        submit = gr.Button("Execute")
+        output = gr.Textbox(label="Result")
+        memory_out = gr.Textbox(label="Memory Snapshot", lines=6)
+        submit.click(run_task, inputs=chatbot, outputs=[output, memory_out])
+
+    with gr.Tab("🧠 Memory Editor"):
+        mem_editor = gr.Textbox(label="Edit memory.txt", lines=10)
+        save_mem = gr.Button("Save Changes")
+        result = gr.Textbox(label="Status")
+        save_mem.click(update_memory, inputs=mem_editor, outputs=result)
+        demo.load(read_memory, inputs=[], outputs=mem_editor)
+
+    with gr.Tab("📁 Recent Logs"):
+        log_output = gr.Textbox(label="Last 5 Logs", lines=20)
+        refresh_logs = gr.Button("Refresh")
+        refresh_logs.click(view_logs, outputs=log_output)
+        demo.load(view_logs, outputs=log_output)
+
+    with gr.Tab("⭐ Feedback"):
+        gr.Markdown("Rate the last task:")
+        feedback_slider = gr.Slider(0, 10, step=0.5, label="Rating")
+        submit_fb = gr.Button("Submit Feedback")
+        fb_result = gr.Textbox(label="Status")
+        submit_fb.click(store_feedback, inputs=feedback_slider, outputs=fb_result)
 
-    def respond(message):
-        result = run_autonomous_loop(message)
-        return [(message, result)]
+    with gr.Tab("🔁 Loop Mode"):
+        interval = gr.Slider(10, 300, step=10, label="Loop interval (seconds)", value=60)
+        toggle = gr.Checkbox(label="Enable Autonomous Loop")
+        loop_status = gr.Textbox(label="Loop Status")
+        toggle.change(fn=toggle_loop, inputs=[toggle, interval], outputs=loop_status)
 
-    button.click(respond, inputs=user_input, outputs=chatbot)
+    with gr.Tab("🧬 Agent Code Editor"):
+        code_box = gr.Code(label="Edit agent.py")
+        code_status = gr.Textbox(label="Update Result")
+        code_save = gr.Button("Save agent.py")
+        demo.load(read_agent_code, outputs=code_box)
+        code_save.click(update_agent_code, inputs=code_box, outputs=code_status)
 
 demo.launch()

runtime.txt

@@ -0,0 +1 @@
+python-3.10

utils.py

@@ -0,0 +1,49 @@
+
+import os
+import json
+from datetime import datetime
+
+def save_log(task, plan, code, result):
+    os.makedirs("logs", exist_ok=True)
+    log_data = {
+        "timestamp": str(datetime.now()),
+        "task": task,
+        "plan": plan,
+        "code": code,
+        "result": result
+    }
+    with open(f"logs/{datetime.now().strftime('%Y%m%d_%H%M%S')}.json", "w") as f:
+        json.dump(log_data, f, indent=2)
+
+def read_memory():
+    if not os.path.exists("memory.txt"):
+        return ""
+    with open("memory.txt", "r") as f:
+        return f.read()
+
+def write_memory(entry):
+    with open("memory.txt", "a") as f:
+        f.write(entry + "\n")
+
+def plan_task(task):
+    return f"Break the task into steps and generate executable code to achieve: '{task}'"
+
+def generate_code(task):
+    return f"# Auto-generated code to {task}\nprint('Completed task: {task}')"
+
+def run_code(code):
+    local_vars = {}
+    exec(code, {}, local_vars)
+    return "Code executed successfully."
+
+def append_feedback(task, result, feedback_score):
+    import json, os, time
+    feedback_entry = {
+        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "task": task,
+        "result": result,
+        "feedback": feedback_score
+    }
+    os.makedirs("feedback", exist_ok=True)
+    with open(f"feedback/{int(time.time())}.json", "w") as f:
+        json.dump(feedback_entry, f, indent=2)