Update backend.py

backend.py

@@ -6,20 +6,24 @@ import zipfile
 import tempfile
 import subprocess
 import re
-from huggingface_hub import whoami
+import concurrent.futures
+from typing import List, Dict, Any
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch
 
-DB_PATH = "code_agents.db"
+DB_PATH = "code_agents_pro.db"
 PROJECT_ROOT = "./projects"
 os.makedirs(PROJECT_ROOT, exist_ok=True)
 
+# ------------------------------ DATABASE ------------------------------
 def init_db():
     conn = sqlite3.connect(DB_PATH)
     cursor = conn.cursor()
     cursor.executescript("""
         CREATE TABLE IF NOT EXISTS users (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
-            hf_token TEXT UNIQUE NOT NULL,
-            username TEXT,
+            username TEXT UNIQUE NOT NULL,
+            password_hash TEXT NOT NULL,
             created_at DATETIME DEFAULT CURRENT_TIMESTAMP
         );
         CREATE TABLE IF NOT EXISTS projects (
@@ -27,69 +31,274 @@ def init_db():
             user_id INTEGER NOT NULL,
             title TEXT,
             description TEXT,
+            status TEXT DEFAULT 'queued', -- queued, running, completed, failed
             zip_path TEXT,
             created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
             FOREIGN KEY (user_id) REFERENCES users(id)
         );
+        CREATE INDEX idx_user_status ON projects(user_id, status);
     """)
     conn.commit()
     conn.close()
 
 init_db()
 
-def get_user_by_token(hf_token):
+def hash_password(password):
+    # In production, use bcrypt or argon2. For now, simple hash for demo.
+    import hashlib
+    return hashlib.sha256(password.encode()).hexdigest()
+
+def verify_password(password, stored_hash):
+    return hash_password(password) == stored_hash
+
+def create_user(username, password):
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    try:
+        cursor.execute("INSERT INTO users (username, password_hash) VALUES (?, ?)", 
+                       (username, hash_password(password)))
+        user_id = cursor.lastrowid
+        conn.commit()
+        conn.close()
+        return user_id
+    except sqlite3.IntegrityError:
+        conn.close()
+        return None
+
+def get_user_by_username(username):
     conn = sqlite3.connect(DB_PATH)
     cursor = conn.cursor()
-    cursor.execute("SELECT id, username FROM users WHERE hf_token = ?", (hf_token,))
+    cursor.execute("SELECT id, password_hash FROM users WHERE username = ?", (username,))
     row = cursor.fetchone()
     conn.close()
     return row if row else None
 
-def create_user(hf_token, username=None):
+def get_user_projects(user_id, limit=3):
     conn = sqlite3.connect(DB_PATH)
     cursor = conn.cursor()
-    cursor.execute("INSERT INTO users (hf_token, username) VALUES (?, ?)", (hf_token, username))
-    user_id = cursor.lastrowid
-    conn.commit()
+    cursor.execute("""
+        SELECT id, title, description, status, zip_path, created_at
+        FROM projects WHERE user_id = ? ORDER BY created_at DESC LIMIT ?
+    """, (user_id, limit))
+    projects = cursor.fetchall()
     conn.close()
-    return user_id
+    return projects
 
-def create_project(user_id, title, description, zip_path):
+def create_project(user_id, title, description):
     conn = sqlite3.connect(DB_PATH)
     cursor = conn.cursor()
     cursor.execute("""
-        INSERT INTO projects (user_id, title, description, zip_path)
-        VALUES (?, ?, ?, ?)
-    """, (user_id, title, description, zip_path))
+        INSERT INTO projects (user_id, title, description, status)
+        VALUES (?, ?, ?, 'queued')
+    """, (user_id, title, description))
     project_id = cursor.lastrowid
     conn.commit()
     conn.close()
     return project_id
 
-def get_user_projects(user_id):
+def update_project_status(project_id, status, zip_path=None):
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    if zip_path:
+        cursor.execute("""
+            UPDATE projects SET status = ?, zip_path = ? WHERE id = ?
+        """, (status, zip_path, project_id))
+    else:
+        cursor.execute("""
+            UPDATE projects SET status = ? WHERE id = ?
+        """, (status, project_id))
+    conn.commit()
+    conn.close()
+
+def get_project(project_id):
     conn = sqlite3.connect(DB_PATH)
     cursor = conn.cursor()
     cursor.execute("""
-        SELECT id, title, description, zip_path, created_at
-        FROM projects WHERE user_id = ? ORDER BY created_at DESC
-    """, (user_id,))
-    projects = cursor.fetchall()
+        SELECT id, user_id, title, description, status, zip_path
+        FROM projects WHERE id = ?
+    """, (project_id,))
+    row = cursor.fetchone()
     conn.close()
-    return projects
+    return row
 
-def verify_hf_token(token):
-    try:
-        user_info = whoami(token=token)
-        username = user_info.get("name", "Anonymous")
-        user = get_user_by_token(token)
-        if not user:
-            user_id = create_user(token, username)
-            return user_id, f"Welcome to Code Agents, {username}! Your AI team is ready."
-        else:
-            return user[0], f"Welcome back, {user[1]}! Your projects are waiting."
-    except Exception as e:
-        return None, f"Invalid token. Please try again. ({str(e)})"
+def search_projects(user_id, query):
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("""
+        SELECT id, title, description, status, zip_path
+        FROM projects WHERE user_id = ? AND (title LIKE ? OR description LIKE ?)
+        ORDER BY created_at DESC
+    """, (user_id, f"%{query}%", f"%{query}%"))
+    results = cursor.fetchall()
+    conn.close()
+    return results
+
+# ------------------------------ MODEL LOADING (PER ROLE) ------------------------------
+# Each role gets the best-suited model — no compromises
+
+MODEL_REGISTRY = {
+    "understander": "Qwen/Qwen2.5-Coder-0.6B-Instruct",
+    "architect": "Qwen/Qwen2.5-Coder-0.6B-Instruct",
+    "ceo": "google/gemma-2-2b-it",
+    "manager": "microsoft/Phi-3-mini-4k-instruct",
+    "worker": "Qwen/Qwen2.5-Coder-0.6B-Instruct",
+    "reviewer": "microsoft/Phi-3-mini-4k-instruct",
+    "editor": "Qwen/Qwen2.5-Coder-0.6B-Instruct",
+    "tester": "microsoft/Phi-3-mini-4k-instruct",
+    "publisher": "Qwen/Qwen2.5-Coder-0.6B-Instruct",
+}
+
+# Load models once at startup
+_MODEL_CACHE = {}
+
+def load_model(model_name):
+    if model_name in _MODEL_CACHE:
+        return _MODEL_CACHE[model_name]
+    
+    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name,
+        torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+        device_map="auto",
+        trust_remote_code=True
+    )
+    _MODEL_CACHE[model_name] = (tokenizer, model)
+    return tokenizer, model
+
+# ------------------------------ PROMPTS PER ROLE ------------------------------
+ROLE_PROMPTS = {
+    "understander": """
+You are the Understander. Your job is to deeply analyze the user's project request.
+Extract:
+- Core functionality
+- Required libraries
+- File structure
+- Edge cases
+
+Output only JSON:
+{
+  "purpose": "string",
+  "features": ["list of features"],
+  "dependencies": ["list of required pip packages"],
+  "files": [
+    {"path": "filename.py", "type": "source|test|config|other"},
+    ...
+  ]
+}
+""",
+
+    "architect": """
+You are the Architect. Based on the Understander's analysis, design the full project structure.
+Define:
+- Folder hierarchy
+- File contents (minimal skeleton)
+- Configuration files
+
+Output only JSON:
+{
+  "structure": [
+    {"path": "src/main.py", "content": "// empty file"},
+    {"path": "requirements.txt", "content": "flask\\nrequests"}
+  ],
+  "notes": "Brief notes on architecture decisions"
+}
+""",
+
+    "ceo": """
+You are the CEO. You oversee the entire project. You receive input from the Architect.
+Your job is to review the plan, ensure alignment with goals, and assign tasks to Managers.
+Respond only with: "Approved. Assigning to Managers."
+""",
+
+    "manager": """
+You are a Manager. You receive a task from the CEO.
+Assign work to Workers based on file type.
+Example:
+- "Write src/main.py" → assign to Worker A
+- "Write tests/test_main.py" → assign to Worker B
+
+Return only JSON:
+{
+  "tasks": [
+    {"file": "src/main.py", "assigned_to": "worker", "instructions": "Write a Flask route..."},
+    {"file": "tests/test_main.py", "assigned_to": "worker", "instructions": "Write a test for the /upload endpoint..."}
+  ]
+}
+""",
+
+    "worker": """
+You are a Worker. You write clean, functional code based on instructions.
+Never guess. Use tools if needed.
+Only output the raw file content — no markdown, no explanations.
+If writing Python, use proper imports, error handling, comments.
+
+File: {file}
+Instructions: {instructions}
+""",
+    
+    "reviewer": """
+You are the Reviewer. You audit all code written by Workers.
+Check for:
+- Security flaws (eval(), shell injection)
+- Missing error handling
+- Unused imports
+- Poor variable names
+- Logic errors
+
+For each issue, return:
+{
+  "file": "path/to/file.py",
+  "issue": "description",
+  "suggestion": "fix suggestion"
+}
 
+If no issues: return {"issues": []}
+""",
+
+    "editor": """
+You are the Editor. Apply all Reviewer suggestions to the code.
+Update files directly.
+Do not explain — just rewrite the file content.
+If a file doesn't exist, create it.
+Return only the updated file content.
+""",
+
+    "tester": """
+You are a Tester. Write unit tests for each source file.
+Use pytest. Structure:
+- File: tests/test_{filename}.py
+- Use assert statements
+- Cover edge cases
+
+Only output the test file content — nothing else.
+""",
+    
+    "publisher": """
+You are the Publisher. Finalize the project.
+Generate:
+- README.md (plain text, no markdown formatting)
+- Dockerfile
+- requirements.txt (complete, deduplicated)
+- .gitignore
+
+Output each file as:
+{
+  "README.md": "...",
+  "Dockerfile": "...",
+  "requirements.txt": "...",
+  ".gitignore": "venv/\n__pycache__/"
+}
+""",
+    
+    "final_ceo": """
+You are the final CEO. You receive the packaged project from the Publisher.
+Verify everything is complete and correct.
+If yes: respond with "Ready to package."
+If no: list missing items.
+"""
+}
+
+# ------------------------------ TOOLS (SAME AS BEFORE) ------------------------------
 def get_user_project_dir(user_id):
     user_dir = os.path.join(PROJECT_ROOT, str(user_id))
     os.makedirs(user_dir, exist_ok=True)
@@ -105,8 +314,6 @@ def clear_user_project_dir(user_id):
         else:
             os.remove(path)
 
-TOOLS = {}
-
 def create_file(user_id, path: str, content: str):
     user_dir = get_user_project_dir(user_id)
     full_path = os.path.join(user_dir, path.lstrip("/"))
@@ -166,35 +373,21 @@ def scan_vulns(user_id):
     result = subprocess.run(["pip-audit", "-r", reqs], capture_output=True, text=True)
     return result.stdout if result.returncode != 0 else "No known vulnerabilities found."
 
-def search_hf_docs(query: str):
-    return f"Searching Hugging Face docs for: '{query}' -> Found: https://huggingface.co/docs/transformers/main/en/quicktour"
-
-def write_readme(user_id, project_name: str, description: str):
-    user_dir = get_user_project_dir(user_id)
-    readme_content = f"""Project Name: {project_name}
-
-Description:
-{description}
-
-How to Run:
-1. Install dependencies: pip install -r requirements.txt
-2. Run the main file: python cli.py
+def generate_dockerfile(user_id, content: str):
+    create_file(user_id, "Dockerfile", content)
+    return "Dockerfile generated."
 
-This project was built by Code Agents — an AI team on Hugging Face.
-"""
-    create_file(user_id, "README.md", readme_content)
+def write_readme(user_id, content: str):
+    create_file(user_id, "README.md", content)
     return "README.md generated."
 
-def generate_dockerfile(user_id):
-    user_dir = get_user_project_dir(user_id)
-    dockerfile = """FROM python:3.10-slim
-COPY . /app
-WORKDIR /app
-RUN pip install --no-cache-dir -r requirements.txt
-CMD ["python", "cli.py"]
-"""
-    create_file(user_id, "Dockerfile", dockerfile)
-    return "Dockerfile generated."
+def write_requirements(user_id, content: str):
+    create_file(user_id, "requirements.txt", content)
+    return "requirements.txt generated."
+
+def write_gitignore(user_id, content: str):
+    create_file(user_id, ".gitignore", content)
+    return ".gitignore generated."
 
 def zip_project(user_id, project_name: str):
     user_dir = get_user_project_dir(user_id)
@@ -208,165 +401,176 @@ def zip_project(user_id, project_name: str):
                 zf.write(full_path, arcname)
     return zip_path
 
-def fix_error(error_msg: str, code: str):
-    if "ModuleNotFoundError" in error_msg and "yt_dlp" in error_msg:
-        return "Add 'yt-dlp' to requirements.txt"
-    elif "SyntaxError" in error_msg:
-        return "Fix indentation or missing colon"
-    return "Unable to auto-fix. Please review manually."
-
-TOOLS = {
-    "create_file": {"func": create_file, "desc": "Create a new file at specified path with content"},
-    "read_file": {"func": read_file, "desc": "Read content of a file"},
-    "list_files": {"func": list_files, "desc": "List all files in the project directory"},
-    "execute_code": {"func": execute_code, "desc": "Execute Python code and return stdout/stderr"},
-    "run_tests": {"func": run_tests, "desc": "Run pytest on test files in /tests directory"},
-    "lint_code": {"func": lint_code, "desc": "Run flake8 to check code style and errors"},
-    "scan_vulns": {"func": scan_vulns, "desc": "Scan dependencies for security vulnerabilities"},
-    "search_hf_docs": {"func": search_hf_docs, "desc": "Search Hugging Face documentation for model usage"},
-    "write_readme": {"func": write_readme, "desc": "Generate a README.md for the project"},
-    "generate_dockerfile": {"func": generate_dockerfile, "desc": "Generate a Dockerfile for containerization"},
-    "zip_project": {"func": zip_project, "desc": "Compress entire project into a downloadable ZIP"},
-    "fix_error": {"func": fix_error, "desc": "Given an error message and code, suggest a fix"}
-}
+# ------------------------------ LLM GENERATOR (CORE ENGINE) ------------------------------
+def generate_with_model(role: str, prompt: str, context: dict = {}) -> str:
+    model_name = MODEL_REGISTRY[role]
+    tokenizer, model = load_model(model_name)
+
+    # Special formatting per role
+    if role == "understander":
+        messages = [{"role": "system", "content": ROLE_PROMPTS["understander"]},
+                    {"role": "user", "content": prompt}]
+    elif role == "architect":
+        messages = [{"role": "system", "content": ROLE_PROMPTS["architect"]},
+                    {"role": "user", "content": prompt}]
+    elif role == "ceo":
+        messages = [{"role": "system", "content": ROLE_PROMPTS["ceo"]},
+                    {"role": "user", "content": prompt}]
+    elif role == "manager":
+        messages = [{"role": "system", "content": ROLE_PROMPTS["manager"]},
+                    {"role": "user", "content": prompt}]
+    elif role == "worker":
+        messages = [{"role": "system", "content": ROLE_PROMPTS["worker"].format(file=context.get("file"), instructions=context.get("instructions"))},
+                    {"role": "user", "content": ""}]
+    elif role == "reviewer":
+        messages = [{"role": "system", "content": ROLE_PROMPTS["reviewer"]},
+                    {"role": "user", "content": prompt}]
+    elif role == "editor":
+        messages = [{"role": "system", "content": ROLE_PROMPTS["editor"]},
+                    {"role": "user", "content": prompt}]
+    elif role == "tester":
+        messages = [{"role": "system", "content": ROLE_PROMPTS["tester"]},
+                    {"role": "user", "content": prompt}]
+    elif role == "publisher":
+        messages = [{"role": "system", "content": ROLE_PROMPTS["publisher"]},
+                    {"role": "user", "content": prompt}]
+    elif role == "final_ceo":
+        messages = [{"role": "system", "content": ROLE_PROMPTS["final_ceo"]},
+                    {"role": "user", "content": prompt}]
+    else:
+        messages = [{"role": "user", "content": prompt}]
+
+    text = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True
+    )
+
+    inputs = tokenizer(text, return_tensors="pt").to(model.device)
+
+    outputs = model.generate(
+        **inputs,
+        max_new_tokens=512,
+        temperature=0.2,
+        top_p=0.9,
+        do_sample=True,
+        pad_token_id=tokenizer.eos_token_id,
+        eos_token_id=tokenizer.eos_token_id
+    )
+
+    response = tokenizer.decode(outputs[0][len(inputs["input_ids"][0]):], skip_special_tokens=True)
+    return response.strip()
+
+# ------------------------------ ASYNC JOB EXECUTOR ------------------------------
+def run_agent_chain(project_id, user_id, initial_prompt):
+    try:
+        update_project_status(project_id, "running")
 
-AGENT_PROMPTS = {
-    "architect": """
-You are an expert software architect. Your job is to plan the project structure.
-Given a user request, decide:
-- File/folder structure
-- Required libraries
-- Tech stack (e.g., Flask, CLI, etc.)
+        user_dir = get_user_project_dir(user_id)
+        clear_user_project_dir(user_id)
 
-Respond only in JSON format:
-{
-  "plan": "Brief plan",
-  "files": [
-    {"path": "cli.py", "content": "// initial code"},
-    {"path": "requirements.txt", "content": "yt-dlp\\nflask"}
-  ]
-}
-""",
-    "coder": """
-You are a senior Python developer. Write clean, efficient, well-commented code.
-Use the tools available: create_file, read_file, execute_code, search_hf_docs.
-Never guess — use tools to verify.
-When done, write the file using create_file().
-""",
-    "tester": """
-You are a QA engineer. Write unit tests for all functions.
-Use pytest. Create test files in /tests/.
-Use execute_code() to run tests and verify output.
-If tests fail, ask coder to fix.
-""",
-    "reviewer": """
-You are a security and code review expert.
-Check for:
-- Security flaws (e.g., eval(), shell injection)
-- Poor practices
-- Missing error handling
-- Unused imports
-Use lint_code(), scan_vulns(), read_file()
-Suggest fixes using fix_error(). Update files with create_file().
-""",
-    "deployer": """
-You are a DevOps engineer.
-Generate:
-- README.md with usage instructions
-- Dockerfile
-- ZIP archive of project
-Use: write_readme(), generate_dockerfile(), zip_project()
-Return final ZIP path when done.
-"""
-}
+        # Step 1: Understander
+        understand_result = generate_with_model("understander", initial_prompt)
+        update_project_status(project_id, "running", f"Understood: {understand_result[:100]}...")
+
+        # Step 2: Architect
+        architect_result = generate_with_model("architect", understand_result)
+        update_project_status(project_id, "running", "Architected structure.")
 
-class Agent:
-    def __init__(self, name: str, prompt: str, tools: dict, user_id: int):
-        self.name = name
-        self.prompt = prompt
-        self.tools = tools
-        self.user_id = user_id
-        self.memory = []
+        # Parse architect JSON
+        try:
+            import json
+            arch_data = json.loads(architect_result)
+            for file in arch_data.get("structure", []):
+                create_file(user_id, file["path"], file["content"])
+        except:
+            pass
+
+        # Step 3: CEO
+        ceo_response = generate_with_model("ceo", "Review architecture and approve.")
+        update_project_status(project_id, "running", "CEO approved.")
 
-    def think(self, task: str) -> str:
-        return f"[{self.name}] {task} (simulated)"
+        # Step 4: Manager assigns tasks
+        manager_response = generate_with_model("manager", "Assign tasks based on architecture.")
+        update_project_status(project_id, "running", "Manager assigned tasks.")
 
-    def act(self, action: str) -> str:
         try:
-            if "(" not in action or ")" not in action:
-                return "Invalid action format"
-            func_name = action.split("(")[0]
-            args_str = action[len(func_name)+1:-1]
-            args = {}
-            if args_str:
-                for pair in args_str.split(","):
-                    k, v = pair.split("=")
-                    args[k.strip()] = v.strip().strip('"\'')
-            if func_name in self.tools:
-                bound_func = lambda **kwargs: self.tools[func_name]["func"](self.user_id, **kwargs)
-                return bound_func(**args)
-            return f"Unknown tool: {func_name}"
-        except Exception as e:
-            return f"Error executing {action}: {str(e)}"
-
-    def run(self, task: str) -> str:
-        response = self.think(task)
-        self.memory.append(f"{self.name}: {response}")
-        
-        actions = re.findall(r'(\w+\(.*?\))', response)
-        for action in actions:
-            result = self.act(action)
-            self.memory.append(f"{self.name} → {action} → {result}")
-        
-        return "\n".join(self.memory[-5:])
-
-def run_code_agents(user_id: int, project_description: str):
-    clear_user_project_dir(user_id)
-    user_dir = get_user_project_dir(user_id)
+            import json
+            tasks = json.loads(manager_response).get("tasks", [])
+            for task in tasks:
+                worker_response = generate_with_model("worker", "", context={
+                    "file": task["file"],
+                    "instructions": task["instructions"]
+                })
+                create_file(user_id, task["file"], worker_response)
+        except:
+            pass
+
+        # Step 5: Reviewer
+        all_files = "\n".join(list_files(user_id))
+        reviewer_input = f"Review these files:\n\n{all_files}"
+        reviewer_result = generate_with_model("reviewer", reviewer_input)
+        update_project_status(project_id, "running", "Reviewer audited code.")
+
+        # Step 6: Editor applies fixes
+        editor_input = f"Apply these changes:\n{reviewer_result}\n\nFiles:\n{all_files}"
+        editor_response = generate_with_model("editor", editor_input)
+        update_project_status(project_id, "running", "Editor applied fixes.")
+
+        # Step 7: Testers generate tests
+        for filename in [f for f in list_files(user_id) if f.endswith(".py") and not f.startswith("test_")]:
+            test_prompt = f"Write a test for this file: {filename}"
+            test_content = generate_with_model("tester", test_prompt)
+            test_path = f"tests/test_{os.path.basename(filename)}"
+            create_file(user_id, test_path, test_content)
+        update_project_status(project_id, "running", "Testers wrote unit tests.")
+
+        # Step 8: Editor reviews tests
+        test_files = "\n".join([f for f in list_files(user_id) if f.startswith("tests/")])
+        editor_test_input = f"Review these test files:\n\n{test_files}\n\nMake sure they are complete and correct."
+        editor_test_response = generate_with_model("editor", editor_test_input)
+        update_project_status(project_id, "running", "Editor reviewed tests.")
+
+        # Step 9: Publisher creates final assets
+        publisher_input = "Generate final project assets: README.md, Dockerfile, requirements.txt, .gitignore"
+        publisher_response = generate_with_model("publisher", publisher_input)
+        update_project_status(project_id, "running", "Publisher generated assets.")
 
-    agents = {
-        "architect": Agent("Architect", AGENT_PROMPTS["architect"], TOOLS, user_id),
-        "coder": Agent("Coder", AGENT_PROMPTS["coder"], TOOLS, user_id),
-        "tester": Agent("Tester", AGENT_PROMPTS["tester"], TOOLS, user_id),
-        "reviewer": Agent("Reviewer", AGENT_PROMPTS["reviewer"], TOOLS, user_id),
-        "deployer": Agent("Deployer", AGENT_PROMPTS["deployer"], TOOLS, user_id),
-    }
-
-    timeline = []
-    logs = ""
-
-    logs += "Architect planning...\n"
-    plan = agents["architect"].run(f"Plan a project: {project_description}")
-    timeline.append({"agent": "architect", "step": "plan", "output": plan})
-    logs += plan + "\n\n"
-
-    logs += "Coder implementing...\n"
-    coder_task = f"Implement the project based on this plan:\n{plan}"
-    coder_result = agents["coder"].run(coder_task)
-    timeline.append({"agent": "coder", "step": "implement", "output": coder_result})
-    logs += coder_result + "\n\n"
-
-    logs += "Tester adding tests...\n"
-    test_task = "Write tests for the implemented code. Save to /tests/test_main.py"
-    test_result = agents["tester"].run(test_task)
-    timeline.append({"agent": "tester", "step": "test", "output": test_result})
-    logs += test_result + "\n\n"
-
-    logs += "Reviewer checking code...\n"
-    review_task = "Review all files. Fix any bugs or security issues."
-    review_result = agents["reviewer"].run(review_task)
-    timeline.append({"agent": "reviewer", "step": "review", "output": review_result})
-    logs += review_result + "\n\n"
-
-    logs += "Deployer packaging...\n"
-    deploy_task = f"Package the project named '{project_description[:20]}...' into a ZIP with README and Dockerfile."
-    deploy_result = agents["deployer"].run(deploy_task)
-    timeline.append({"agent": "deployer", "step": "deploy", "output": deploy_result})
-
-    zip_files = [f for f in os.listdir(user_dir) if f.endswith(".zip")]
-    zip_path = os.path.join(user_dir, zip_files[0]) if zip_files else None
+        try:
+            import json
+            pub_data = json.loads(publisher_response)
+            for fname, content in pub_data.items():
+                if fname == "README.md":
+                    write_readme(user_id, content)
+                elif fname == "Dockerfile":
+                    generate_dockerfile(user_id, content)
+                elif fname == "requirements.txt":
+                    write_requirements(user_id, content)
+                elif fname == ".gitignore":
+                    write_gitignore(user_id, content)
+        except:
+            pass
+
+        # Step 10: Final CEO
+        final_input = "All files generated. Verify completeness."
+        final_ceo_response = generate_with_model("final_ceo", final_input)
+        update_project_status(project_id, "running", "Final CEO verified.")
+
+        if "Ready to package" not in final_ceo_response:
+            raise Exception(f"Final CEO rejected: {final_ceo_response}")
+
+        # Step 11: ZIP & Save
+        zip_path = zip_project(user_id, f"project_{project_id}")
+        update_project_status(project_id, "completed", zip_path)
+
+        return "Completed successfully"
 
-    if zip_path:
-        project_id = create_project(user_id, project_description[:50], project_description, zip_path)
+    except Exception as e:
+        update_project_status(project_id, "failed", str(e))
+        return f"Failed: {str(e)}"
+
+# ------------------------------ JOB QUEUE ------------------------------
+executor = concurrent.futures.ThreadPoolExecutor(max_workers=2)
 
-    return logs, zip_path, timeline
+def queue_job(project_id, user_id, prompt):
+    executor.submit(run_agent_chain, project_id, user_id, prompt)