Initial commit

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "python.analysis.extraPaths": [
+        "./api"
+    ]
+}

api/Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.10
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+COPY app ./app
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

api/app/agents/backend.py

@@ -0,0 +1,12 @@
+import requests
+from app.config import CODE_MODEL_URL
+
+def backend_agent(plan):
+    payload = {
+        "model": "deepseek-ai/DeepSeek-Coder-V2-Instruct",
+        "messages": [{"role": "user", "content": f"Generate FastAPI backend:\n{plan}"}],
+        "temperature": 0.2
+    }
+
+    r = requests.post(CODE_MODEL_URL, json=payload)
+    return r.json()["choices"][0]["message"]["content"]

api/app/agents/devops.py

@@ -0,0 +1,32 @@
+import requests
+from app.config import REASON_MODEL_URL
+
+MODEL_NAME = "Qwen/Qwen2.5-7B-Instruct"
+
+
+def devops_agent(plan: str) -> str:
+    prompt = f"""
+    You are a DevOps engineer.
+
+    Based on this project plan:
+    {plan}
+
+    Generate:
+    - Dockerfile for backend
+    - docker-compose.yml
+    - Production deployment notes
+    - Environment variables structure
+
+    Return clean production-ready configuration files.
+    """
+
+    payload = {
+        "model": MODEL_NAME,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.2,
+    }
+
+    response = requests.post(REASON_MODEL_URL, json=payload, timeout=300)
+    response.raise_for_status()
+
+    return response.json()["choices"][0]["message"]["content"]

api/app/agents/frontend.py

@@ -0,0 +1,32 @@
+import requests
+from app.config import CODE_MODEL_URL
+
+MODEL_NAME = "deepseek-ai/DeepSeek-Coder-V2-Instruct"
+
+
+def frontend_agent(plan: str) -> str:
+    prompt = f"""
+    You are a senior frontend engineer.
+
+    Based on this backend plan:
+    {plan}
+
+    Generate:
+    - NextJS app structure
+    - API integration example
+    - Auth integration
+    - Clean folder structure
+
+    Return full production-ready frontend code.
+    """
+
+    payload = {
+        "model": MODEL_NAME,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.3,
+    }
+
+    response = requests.post(CODE_MODEL_URL, json=payload, timeout=300)
+    response.raise_for_status()
+
+    return response.json()["choices"][0]["message"]["content"]

api/app/agents/planner.py

@@ -0,0 +1,12 @@
+import requests
+from app.config import REASON_MODEL_URL
+
+def planner_agent(prompt):
+    payload = {
+        "model": "Qwen/Qwen3-Coder-480B-A35B-Instruct",
+        "messages": [{"role": "user", "content": f"Break this task into steps:\n{prompt}"}],
+        "temperature": 0.2
+    }
+
+    r = requests.post(REASON_MODEL_URL, json=payload)
+    return r.json()["choices"][0]["message"]["content"]

api/app/agents/reviewer.py

@@ -0,0 +1,33 @@
+import requests
+from app.config import REASON_MODEL_URL
+
+MODEL_NAME = "Qwen/Qwen3-Coder-480B-A35B-Instruct"
+
+
+def reviewer_agent(code: str) -> str:
+    prompt = f"""
+    You are a senior code reviewer.
+
+    Review the following code:
+    - Fix bugs
+    - Improve performance
+    - Improve structure
+    - Remove duplication
+    - Add missing error handling
+
+    Return improved version only.
+
+    CODE:
+    {code}
+    """
+
+    payload = {
+        "model": MODEL_NAME,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.1,
+    }
+
+    response = requests.post(REASON_MODEL_URL, json=payload, timeout=300)
+    response.raise_for_status()
+
+    return response.json()["choices"][0]["message"]["content"]

api/app/config.py

@@ -0,0 +1,5 @@
+CODE_MODEL_URL = "http://vllm-code:8000/v1/chat/completions"
+REASON_MODEL_URL = "http://vllm-reason:8000/v1/chat/completions"
+
+REDIS_HOST = "redis"
+REDIS_PORT = 6379

api/app/main.py

@@ -0,0 +1,14 @@
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from fastapi import FastAPI
+from orchestrator import autodev
+
+app = FastAPI()
+
+@app.post("/autodev")
+async def run_autodev(data: dict):
+    result = await autodev(data["prompt"])
+    return result

api/app/orchestrator.py

@@ -0,0 +1,27 @@
+import asyncio
+from agents.planner import planner_agent
+from agents.backend import backend_agent
+from tools.test_runner import run_tests
+
+MAX_ITER = 3
+
+async def autodev(prompt):
+
+    plan = planner_agent(prompt)
+
+    code = backend_agent(plan)
+
+    for _ in range(MAX_ITER):
+
+        with open("generated/main.py", "w") as f:
+            f.write(code)
+
+        status, logs = run_tests()
+
+        if status == 0:
+            return {"status": "success", "code": code}
+
+        fix_prompt = f"Fix this code:\n\n{logs}"
+        code = backend_agent(fix_prompt)
+
+    return {"status": "failed"}

api/app/router.py

@@ -0,0 +1,33 @@
+from sentence_transformers import SentenceTransformer
+import numpy as np
+from sklearn.metrics.pairwise import cosine_similarity
+
+embed_model = SentenceTransformer("BAAI/bge-large-en")
+
+task_map ={
+    "CODE": {
+        "agent": "backend",
+        "prompt": "You are the Backend Architect."
+    },
+    "REASON": {
+        "agent": "planner",
+        "prompt": "You are the Logic Planner."
+    },
+    "CHAT": {
+        "agent": "frontend", 
+        "prompt": "You are the User Interface."
+    }
+}
+
+# Cách sử dụng trong Orchestrator:
+# selected_task = task_map["CODE"]
+# system_prompt = selected_task["system_role"]
+
+
+task_names = list(task_map.keys())
+task_vectors = embed_model.encode(list(task_map.values()))
+
+def route(prompt):
+    prompt_vec = embed_model.encode([prompt])
+    sims = cosine_similarity(prompt_vec, task_vectors)[0]
+    return task_names[np.argmax(sims)]

api/app/tools/docker_sandbox.py

@@ -0,0 +1,57 @@
+import subprocess
+import uuid
+from pathlib import Path
+
+
+class DockerSandbox:
+
+    def __init__(self, project_dir="generated"):
+        self.project_dir = Path(project_dir)
+
+    def build_image(self):
+        image_tag = f"ai_dev_{uuid.uuid4().hex[:8]}"
+
+        cmd = [
+            "docker",
+            "build",
+            "-t",
+            image_tag,
+            str(self.project_dir)
+        ]
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True
+        )
+
+        if result.returncode != 0:
+            return False, result.stderr
+
+        return True, image_tag
+
+    def run_container(self, image_tag, timeout=20):
+        cmd = [
+            "docker",
+            "run",
+            "--rm",
+            "--network", "none",  # Disable internet
+            "--memory", "512m",
+            "--cpus", "1",
+            image_tag
+        ]
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+
+        return result.returncode, result.stdout, result.stderr
+
+    def cleanup_image(self, image_tag):
+        subprocess.run(
+            ["docker", "rmi", "-f", image_tag],
+            capture_output=True
+        )

api/app/tools/file_writer.py

@@ -0,0 +1,36 @@
+import os
+from pathlib import Path
+
+
+class FileWriter:
+
+    BASE_DIR = Path("generated")
+
+    def __init__(self):
+        self.BASE_DIR.mkdir(exist_ok=True)
+
+    def write(self, relative_path: str, content: str, overwrite=True):
+        target_path = self.BASE_DIR / relative_path
+
+        # Prevent directory traversal attack
+        if not str(target_path.resolve()).startswith(str(self.BASE_DIR.resolve())):
+            raise ValueError("Invalid path detected")
+
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+
+        if target_path.exists() and not overwrite:
+            return f"{relative_path} already exists"
+
+        with open(target_path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+        return f"Written: {relative_path}"
+
+    def read(self, relative_path: str):
+        target_path = self.BASE_DIR / relative_path
+
+        if not target_path.exists():
+            return None
+
+        with open(target_path, "r", encoding="utf-8") as f:
+            return f.read()

api/app/tools/test_runner.py

@@ -0,0 +1,9 @@
+import subprocess
+
+def run_tests():
+    result = subprocess.run(
+        ["pytest"],
+        capture_output=True,
+        text=True
+    )
+    return result.returncode, result.stdout + result.stderr

api/requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+uvicorn
+redis
+requests
+asyncio
+pytest

docker-compose.yml

@@ -0,0 +1,40 @@
+version: "3.9"
+
+services:
+
+  redis:
+    image: redis:7
+    ports:
+      - "6379:6379"
+
+  vllm-code:
+    image: vllm/vllm-openai:latest
+    command: >
+      --model deepseek-ai/DeepSeek-Coder-V2-Instruct
+      --dtype float16
+      --port 8001
+    ports:
+      - "8001:8000"
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - capabilities: [gpu]
+
+  vllm-reason:
+    image: vllm/vllm-openai:latest
+    command: >
+      --model Qwen/Qwen3-Coder-480B-A35B-Instruct
+      --dtype float16
+      --port 8002
+    ports:
+      - "8002:8000"
+
+  api:
+    build: ./api
+    ports:
+      - "8000:8000"
+    depends_on:
+      - redis
+      - vllm-code
+      - vllm-reason

worker/worker.py

@@ -0,0 +1,159 @@
+import asyncio
+import json
+import os
+import signal
+import sys
+import traceback
+from typing import Dict
+from pathlib import Path
+
+import redis
+
+sys.path.insert(0, str(Path(__file__).parent.parent / 'api'))
+
+from app.agents.planner import planner_agent
+from app.agents.backend import backend_agent
+from app.agents.frontend import frontend_agent
+from app.agents.devops import devops_agent
+from app.agents.reviewer import reviewer_agent
+from app.tools.file_writer import FileWriter
+from app.tools.docker_sandbox import DockerSandbox
+
+
+# ==============================
+# CONFIG
+# ==============================
+
+REDIS_HOST = os.getenv("REDIS_HOST", "redis")
+REDIS_PORT = int(os.getenv("REDIS_PORT", 6379))
+QUEUE_NAME = os.getenv("QUEUE_NAME", "autodev_queue")
+
+MAX_DEBUG_ITER = 3
+
+
+# ==============================
+# REDIS CONNECTION
+# ==============================
+
+redis_client = redis.Redis(
+    host=REDIS_HOST,
+    port=REDIS_PORT,
+    decode_responses=True,
+)
+
+
+# ==============================
+# WORKER CORE
+# ==============================
+
+class AutoDevWorker:
+
+    def __init__(self):
+        self.file_writer = FileWriter()
+        self.sandbox = DockerSandbox()
+        self.running = True
+
+    async def process_job(self, job_data: Dict):
+
+        prompt = job_data.get("prompt")
+        job_id = job_data.get("job_id")
+
+        print(f"[Worker] Processing job {job_id}")
+
+        # 1️⃣ Planning
+        plan = planner_agent(prompt)
+
+        # 2️⃣ Async parallel generation
+        backend_task = asyncio.to_thread(backend_agent, plan)
+        frontend_task = asyncio.to_thread(frontend_agent, plan)
+        devops_task = asyncio.to_thread(devops_agent, plan)
+
+        backend_code, frontend_code, devops_code = await asyncio.gather(
+            backend_task,
+            frontend_task,
+            devops_task
+        )
+
+        # 3️⃣ Write files
+        self.file_writer.write("backend/main.py", backend_code)
+        self.file_writer.write("frontend/app.js", frontend_code)
+        self.file_writer.write("Dockerfile", devops_code)
+
+        # 4️⃣ Self-debug loop
+        final_backend_code = await self.self_debug("backend/main.py")
+
+        # 5️⃣ Docker sandbox build & run
+        success, image_tag = self.sandbox.build_image()
+
+        result = {
+            "job_id": job_id,
+            "status": "completed",
+            "docker_success": success,
+        }
+
+        if success:
+            status, stdout, stderr = self.sandbox.run_container(image_tag)
+            self.sandbox.cleanup_image(image_tag)
+
+            result["run_status"] = status
+            result["stdout"] = stdout
+            result["stderr"] = stderr
+
+        # 6️⃣ Push result
+        redis_client.set(f"result:{job_id}", json.dumps(result))
+
+        print(f"[Worker] Job {job_id} completed")
+
+    async def self_debug(self, file_path: str):
+
+        for i in range(MAX_DEBUG_ITER):
+            print(f"[Worker] Debug iteration {i+1}")
+
+            code = self.file_writer.read(file_path)
+            improved_code = reviewer_agent(code)
+
+            self.file_writer.write(file_path, improved_code)
+
+        return improved_code
+
+    async def run(self):
+
+        print("[Worker] Started...")
+
+        while self.running:
+            try:
+                job = redis_client.blpop(QUEUE_NAME, timeout=5)
+
+                if job:
+                    _, job_data = job
+                    job_data = json.loads(job_data)
+
+                    await self.process_job(job_data)
+
+            except Exception as e:
+                print("[Worker] ERROR:", str(e))
+                traceback.print_exc()
+
+    def stop(self):
+        print("[Worker] Shutting down...")
+        self.running = False
+
+
+# ==============================
+# ENTRY POINT
+# ==============================
+
+worker = AutoDevWorker()
+
+
+def shutdown_handler(signum, frame):
+    worker.stop()
+    sys.exit(0)
+
+
+signal.signal(signal.SIGINT, shutdown_handler)
+signal.signal(signal.SIGTERM, shutdown_handler)
+
+
+if __name__ == "__main__":
+    asyncio.run(worker.run())