Update app.py

app.py

@@ -1,48 +1,145 @@
-import os
-import torch
-import torch.nn.functional as F
+# Final major enhancement wave:
+# - Add dry-run testing of proposed code using `exec()` in isolated namespace.
+# - Add test result logging to vector memory.
+# - Add internal test cases for agent_core logic to validate before applying updates.
+
+# Update app.py to include dry-run simulation before applying changes
+
+enhanced_app_code = """
 import gradio as gr
-from transformers import AutoTokenizer, AutoModel
-
-# ——— Model loading ———
-MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
-tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-model = AutoModel.from_pretrained(MODEL_NAME)
-
-def mean_pooling(model_output, attention_mask):
-    token_embeddings = model_output[0]                        # first element: token embeddings
-    mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
-    return torch.sum(token_embeddings * mask_expanded, 1) / torch.clamp(mask_expanded.sum(1), min=1e-9)
-
-# ——— Inference function ———
-def compute_similarity(sent1: str, sent2: str) -> float:
-    # Tokenize
-    encoded = tokenizer([sent1, sent2], padding=True, truncation=True, return_tensors="pt")
-    # Forward pass
-    with torch.no_grad():
-        output = model(**encoded)
-    # Pool & normalize
-    embeddings = mean_pooling(output, encoded["attention_mask"])
-    embeddings = F.normalize(embeddings, p=2, dim=1)
-    # Cosine similarity
-    sim = float((embeddings[0] @ embeddings[1]).item())
-    return round(sim, 4)
-
-# ——— Gradio interface ———
-demo = gr.Interface(
-    fn=compute_similarity,
-    inputs=[
-        gr.Textbox(label="Sentence 1", lines=2, placeholder="Enter first sentence..."),
-        gr.Textbox(label="Sentence 2", lines=2, placeholder="Enter second sentence...")
-    ],
-    outputs=gr.Number(label="Cosine Similarity"),
-    title="Sentence Embedding Similarity",
-    description="Compute the cosine similarity between the embeddings of two sentences using MiniLM."
-)
-
-if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=int(os.environ.get("PORT", 7860)),
-        share=False
-    )
+import os
+import openai
+import subprocess
+import json
+import time
+from difflib import unified_diff
+
+STATE_FILE = "agent_state.txt"
+LOG_FILE = "agent_log.txt"
+AGENT_CODE = "agent_core.py"
+CONFIG_FILE = "config.json"
+MEMORY_FILE = "vector_memory.json"
+TASKS_FILE = "tasks.json"
+
+def log(message):
+    with open(LOG_FILE, "a") as f:
+        f.write(f"{time.ctime()}: {message}\\n")
+
+def read_log():
+    if os.path.exists(LOG_FILE):
+        with open(LOG_FILE) as f:
+            return f.read()
+    return "No logs yet."
+
+def save_backup(code):
+    ts = time.strftime("%Y%m%d-%H%M%S")
+    backup_path = f"backup_{ts}.py"
+    with open(backup_path, "w") as f:
+        f.write(code)
+    return backup_path
+
+def evaluate_change(old_code, new_code):
+    prompt = f\"\"\"
+Compare the OLD and NEW version of the agent's core logic.
+Score how much better the new version is in terms of:
+- Intelligence
+- Robustness
+- Self-Improvement
+
+Return a score from -10 to +10 and a reason.
+
+[OLD CODE]
+{old_code}
+
+[NEW CODE]
+{new_code}
+\"\"\"
+    try:
+        response = openai.ChatCompletion.create(
+            model="gpt-4",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.3
+        )
+        return response.choices[0].message["content"].strip()
+    except Exception as e:
+        return f"Evaluation failed: {e}"
+
+def dry_run_test(code):
+    local_env = {}
+    try:
+        exec(code, {}, local_env)
+        return "Dry-run test succeeded."
+    except Exception as e:
+        return f"Dry-run test failed: {e}"
+
+def log_memory(entry):
+    memory = json.load(open(MEMORY_FILE))
+    memory["memory"].append({
+        "timestamp": time.ctime(),
+        "thought": entry
+    })
+    with open(MEMORY_FILE, "w") as f:
+        json.dump(memory, f, indent=4)
+
+def agent_tick():
+    log("Agent tick started.")
+    with open(AGENT_CODE, "r") as f:
+        current_code = f.read()
+
+    prompt = f\"\"\"
+You are a recursive agent that improves itself.
+
+Improve the following Python code to make it more intelligent, autonomous, and safe.
+Return ONLY the improved full Python script.
+
+{current_code}
+\"\"\"
+
+    openai.api_key = os.getenv("OPENAI_API_KEY")
+    try:
+        response = openai.ChatCompletion.create(
+            model="gpt-4",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.5
+        )
+        improved_code = response.choices[0].message["content"]
+
+        if improved_code.strip().startswith("import"):
+            dry_result = dry_run_test(improved_code)
+            log(f"Dry-run result: {dry_result}")
+            log_memory(f"Dry-run: {dry_result}")
+            if "succeeded" in dry_result:
+                score_report = evaluate_change(current_code, improved_code)
+                log(f"Eval: {score_report}")
+                log_memory(f"Eval: {score_report}")
+                save_backup(current_code)
+                with open(AGENT_CODE, "w") as f:
+                    f.write(improved_code)
+                subprocess.run(["git", "add", "."], check=False)
+                subprocess.run(["git", "commit", "-m", "Auto-update by EvolvAI"], check=False)
+                log("Applied improved code.")
+            else:
+                log("Dry-run failed. Skipping update.")
+        else:
+            log("Malformed GPT output. Skipping update.")
+    except Exception as e:
+        log(f"Error during update: {e}")
+        log_memory(f"Update error: {e}")
+
+    return read_log()
+
+def stop_agent():
+    log("Agent manually stopped.")
+    return read_log()
+
+with gr.Blocks() as demo:
+    gr.Markdown("# 🤖 EvolvAI v2: Self-Evolving Agent UI")
+    log_display = gr.Textbox(label="Log Output", lines=20)
+    start_btn = gr.Button("Run Self-Update")
+    stop_btn = gr.Button("Stop Agent")
+
+    start_btn.click(agent_tick, outputs=log_display)
+    stop_btn.click(stop_agent, outputs=log_display)
+
+demo.launch()
+"""