Upload 25 files

.github/workflows/deploy.yml

@@ -0,0 +1,16 @@
+
+name: Deploy Autonomous AI
+
+on:
+  push:
+    branches: [ main ]
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build Docker image
+        run: docker build -t autonomous-ai .
+      - name: Run container
+        run: docker run -d -p 8000:8000 autonomous-ai

README.md

@@ -1,34 +1,32 @@
----
-title: Autonomous AI
-emoji: 🤖
-colorFrom: gray
-colorTo: green
-sdk: gradio
-sdk_version: 5.34.2
-app_file: app.py
-pinned: false
-license: mit
----
-# 🤖 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
+
+# Autonomous AI — Self-Improving Agent
+
+This is an autonomous AI system capable of learning, improving, and handling tasks via API, Webhooks, and a Client Portal.
+
+## 🚀 Features
+- Self-upgrading agent loop
+- Multi-agent collaboration
+- Feedback storage + analytics dashboard
+- Webhook + portal UI
+- Scheduler & voice interface
+
+## 🐳 Deploy with Docker
+
+```bash
+docker build -t autonomous-ai .
+docker run -p 8000:8000 autonomous-ai
+```
+
+Visit: http://localhost:8000/portal
+
+## 🌐 Manual Start (No Docker)
+```bash
+pip install -r requirements.txt
+python -c "from storage import init_db; init_db()"
+uvicorn api:app --reload
+```
+
+## 🛠 Endpoints
+- `/portal` - Task submission UI
+- `/dashboard` - Feedback/goal display
+- `/webhook` - POST task externally

agent.py

@@ -1,24 +1,13 @@
 
-import os
-import traceback
-from datetime import datetime
-from utils import save_log, read_memory, write_memory, plan_task, generate_code, run_code
-
-MEMORY_FILE = "memory.txt"
-LOG_DIR = "logs"
-
-def autonomous_agent(task):
-    try:
-        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:
-        error = traceback.format_exc()
-        save_log(task, "FAILED", "None", error)
-        return f"❌ Task Failed:\n{error}"
+from memory import MemoryVectorStore
+
+memory = MemoryVectorStore()
+
+def run_agent(goal):
+    memory.add(goal)
+    ideas = memory.search(goal)
+    # Assume goal is passed into LLM with memory summary
+    summary = " ".join(ideas)
+    result = f"[Task]: {goal}\n[Memory]: {summary}\n[Response]: working on it..."
+    memory.add(result)
+    return result

api.py

@@ -53,3 +53,19 @@ async def submit_task(goal: str = Form(...)):
 async def dashboard():
     with open("dashboard.html") as f:
         return f.read()
+
+
+from fastapi import Header, HTTPException
+from auth import authorize
+from session import log_interaction, create_session
+
+@app.post("/session_task")
+def session_task(goal: str, x_api_key: str = Header(...), session_id: str = ""):
+    user = authorize(x_api_key)
+    if not user:
+        raise HTTPException(status_code=401, detail="Invalid API key")
+    if not session_id:
+        session_id = create_session(user)
+    output = run_agent(goal)
+    log_interaction(session_id, goal, output)
+    return {"session_id": session_id, "output": output}

auth.py

@@ -1,14 +1,9 @@
 
-from fastapi import Request, HTTPException
-from starlette.middleware.base import BaseHTTPMiddleware
+# Very simple API key system
+AUTHORIZED_KEYS = {
+    "admin-key": "admin",
+    "user-key": "user"
+}
 
-API_KEY = "super-secret-key"  # TODO: Secure this
-
-class APIKeyMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next):
-        if request.url.path.startswith("/"):
-            api_key = request.headers.get("x-api-key")
-            if api_key != API_KEY:
-                raise HTTPException(status_code=401, detail="Invalid API Key")
-        response = await call_next(request)
-        return response
+def authorize(key: str):
+    return AUTHORIZED_KEYS.get(key)

memory.py

@@ -0,0 +1,38 @@
+
+import os
+import faiss
+import pickle
+from sentence_transformers import SentenceTransformer
+from logger import logger
+
+class MemoryVectorStore:
+    def __init__(self, path="memory_index"):
+        self.path = path
+        self.model = SentenceTransformer("all-MiniLM-L6-v2")
+        self.dim = 384
+        self.index = faiss.IndexFlatL2(self.dim)
+        self.memory = []
+        self.load()
+
+    def load(self):
+        if os.path.exists(self.path + ".pkl"):
+            with open(self.path + ".pkl", "rb") as f:
+                data = pickle.load(f)
+                self.memory = data["memory"]
+                self.index = data["index"]
+            logger.info("✅ Memory index loaded")
+
+    def save(self):
+        with open(self.path + ".pkl", "wb") as f:
+            pickle.dump({"memory": self.memory, "index": self.index}, f)
+
+    def add(self, text):
+        vec = self.model.encode([text])
+        self.index.add(vec)
+        self.memory.append(text)
+        self.save()
+
+    def search(self, query, k=3):
+        vec = self.model.encode([query])
+        D, I = self.index.search(vec, k)
+        return [self.memory[i] for i in I[0] if i < len(self.memory)]

session.py

@@ -0,0 +1,26 @@
+
+import sqlite3
+from uuid import uuid4
+
+def init_session_db():
+    conn = sqlite3.connect("sessions.db")
+    conn.execute("CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, user TEXT)")
+    conn.execute("CREATE TABLE IF NOT EXISTS messages (session_id TEXT, user_input TEXT, ai_output TEXT)")
+    conn.commit()
+    conn.close()
+
+def create_session(user):
+    sid = str(uuid4())
+    with sqlite3.connect("sessions.db") as conn:
+        conn.execute("INSERT INTO sessions (id, user) VALUES (?, ?)", (sid, user))
+    return sid
+
+def log_interaction(session_id, user_input, ai_output):
+    with sqlite3.connect("sessions.db") as conn:
+        conn.execute("INSERT INTO messages (session_id, user_input, ai_output) VALUES (?, ?, ?)",
+                     (session_id, user_input, ai_output))
+
+def get_session_logs(session_id):
+    with sqlite3.connect("sessions.db") as conn:
+        rows = conn.execute("SELECT user_input, ai_output FROM messages WHERE session_id=?", (session_id,)).fetchall()
+    return rows