ui.py

import streamlit as st
import os
from blackboard import Blackboard
from agents.analyst import AnalystAgent
from agents.architect import ArchitectAgent
from agents.frontend import FrontendDeveloperAgent
from agents.backend import BackendDeveloperAgent
from agents.reviewer import CodeReviewerAgent
from agents.cleaner import CleanerAgent
from agents.tester import TesterAgent

MAX_CYCLES = 5

def detect_language(filename):
    if filename.endswith(".py"):
        return "python"
    elif filename.endswith(".js"):
        return "javascript"
    elif filename.endswith(".html"):
        return "html"
    elif filename.endswith(".css"):
        return "css"
    else:
        return ""

def display_code(folder_path, label):
    if not os.path.exists(folder_path):
        st.write(f"📂 **No {label} files found in `{folder_path}`.**")
        return

    for root, _, files in os.walk(folder_path):
        for file in files:
            file_path = os.path.join(root, file)
            if any(file.endswith(ext) for ext in [".py", ".html", ".css", ".js"]):
                with open(file_path, "r") as f:
                    content = f.read()
                st.write(f"##### 📄 {label} File: `{os.path.basename(file_path)}`")
                st.code(content, language=detect_language(file))

def run_agents(goal):
    blackboard = Blackboard(goal)

    def log_ui(msg):
        st.write(msg)

    agents = {
        "Analyst": AnalystAgent(blackboard, log=log_ui),
        "Architect": ArchitectAgent(blackboard, log=log_ui),
        "Frontend Developer": FrontendDeveloperAgent(blackboard, log=log_ui),
        "Backend Developer": BackendDeveloperAgent(blackboard, log=log_ui),
        "Reviewer": CodeReviewerAgent(blackboard, log=log_ui),
        "Cleaner": CleanerAgent(blackboard, log=log_ui),
        "Tester": TesterAgent(blackboard, log=log_ui),
    }

    with st.expander("🔍 Analyst Agent"):
        agents["Analyst"].act()

    with st.expander("📐 Architect Agent"):
        agents["Architect"].act()

    for cycle in range(1, MAX_CYCLES + 1):
        st.subheader(f"=== Cycle {cycle} ===")

        if not blackboard.get("frontend_review_passed"):
            with st.expander("🎨 Frontend Developer"):
                frontend_file = agents["Frontend Developer"].act()
                if frontend_file and os.path.exists(frontend_file):
                    with open(frontend_file, "r") as f:
                        code = f.read()
                    st.code(code, language="html")

        if not blackboard.get("backend_review_passed"):
            with st.expander("🔧 Backend Developer"):
                backend_file = agents["Backend Developer"].act()
                if backend_file and os.path.exists(backend_file):
                    with open(backend_file, "r") as f:
                        code = f.read()
                    st.code(code, language=detect_language(backend_file))

        with st.expander("🔎 Code Reviewer"):
            agents["Reviewer"].act()

        frontend_passed = blackboard.get("frontend_review_passed")
        backend_passed = blackboard.get("backend_review_passed")
        frontend_needed = blackboard.get("frontend_needed")
        backend_needed = blackboard.get("backend_needed")

        # FRONTEND ONLY
        if frontend_passed and frontend_needed and not backend_needed:
            with st.expander("🧹 Cleaner - Frontend"):
                agents["Cleaner"].act()
                display_code("cleaned/frontend", "Frontend")
            st.success("🎉 Frontend complete. No backend required. Exiting.")
            return

        # BACKEND ONLY
        if backend_passed and backend_needed and not frontend_needed:
            with st.expander("🧹 Cleaner - Backend"):
                agents["Cleaner"].act()
                display_code("cleaned/backend", "Backend")

            with st.expander("🧪 Tester Agent"):
                agents["Tester"].act()
                display_code("generated/tests", "Generated Tests")

            st.success("🎉 Backend complete. No frontend required. Exiting.")
            return

        # BOTH FRONTEND AND BACKEND
        if frontend_passed and backend_passed:
            st.success("✅ Both Frontend and Backend code passed review!")

            with st.expander("🧹 Final Cleaning"):
                agents["Cleaner"].act()

            display_code("cleaned/frontend", "Final Cleaned Frontend")
            display_code("cleaned/backend", "Final Cleaned Backend")

            with st.expander("🧪 Final Testing"):
                agents["Tester"].act()
                display_code("generated/tests", "Final Generated Tests")

            st.success("🎉 Process complete with code reviewed, cleaned, and tested.")
            return

    st.warning("⚠️ Maximum cycles reached. Some components may still need improvements.")

# Streamlit UI
st.set_page_config("AI Software Dev Pipeline", page_icon="🤖", layout="wide")
st.title("🤖 AI Multi-Agent Software Development")

goal_input = st.text_area("Enter your software goal (include frontend/backend needs):")

if st.button("🚀 Run Agents"):
    if goal_input.strip():
        run_agents(goal_input)
    else:
        st.warning("Please enter a valid software goal to start the process.")