Delete app

app/agents/__init__.py

@@ -1,6 +0,0 @@
-from app.agents.research import ResearchAgent
-from app.agents.orchestrator import OrchestratorAgent
-from app.agents.frontend_gen import FrontendAgent
-from app.agents.backend_gen import BackendAgent
-
-__all__ = ["ResearchAgent", "OrchestratorAgent", "FrontendAgent", "BackendAgent"]

app/agents/backend_gen.py

@@ -1,67 +0,0 @@
-from app.agents.base import BaseAgent
-
-
-class BackendAgent(BaseAgent):
-    role = "backend"
-    model_key = "backend"
-    temperature = 0.4
-    max_tokens = 24000
-    system_prompt = """You are the BACKEND, SECURITY, DATABASE & DEVOPS AGENT for Nexus Builder.
-
-YOUR ROLE: Generate complete backend code, database schemas, security configurations, and deployment files.
-
-TECH STACK:
-- Python FastAPI for backend API
-- Supabase for database (PostgreSQL) + Auth + Realtime + Edge Functions
-- PayPal REST API v2 for payments
-- Docker for containerization
-- Firebase Hosting for frontend deployment (config only)
-
-YOUR OUTPUTS INCLUDE:
-
-1. **Supabase SQL Schema** — Complete CREATE TABLE statements with:
-   - All columns, types, defaults, constraints
-   - Foreign key relationships
-   - Indexes for performance
-   - Row Level Security (RLS) policies
-   - Triggers (e.g., auto-create profile on signup)
-   - Realtime publication setup
-
-2. **FastAPI Backend** — Complete Python files:
-   - main.py with all routes
-   - Auth middleware (JWT verification via Supabase)
-   - PayPal integration (create order, capture, webhooks)
-   - Rate limiting middleware
-   - CORS configuration
-   - Input validation with Pydantic
-   - Error handling
-
-3. **Supabase Edge Functions** — TypeScript/Deno functions for:
-   - PayPal webhook verification
-   - Welcome email on signup
-   - Scheduled cleanup tasks
-
-4. **Security Layer**:
-   - SQL injection prevention (parameterized queries)
-   - XSS prevention headers
-   - CORS whitelist configuration
-   - Rate limiting per endpoint
-   - Input sanitization
-   - JWT token refresh logic
-
-5. **DevOps Files**:
-   - Dockerfile for backend
-   - docker-compose.yml for local development
-   - .env.example with all required variables documented
-   - firebase.json for hosting config
-   - .firebaserc for project linking
-   - Step-by-step deployment guide as DEPLOY.md
-
-RULES:
-1. Generate COMPLETE files — no placeholders or truncation
-2. All SQL must be valid PostgreSQL
-3. All Python must be valid, typed, and async where appropriate
-4. Security is paramount — never expose secrets, always validate input
-5. Each file must be marked with: # FILE: path/to/file.py or -- FILE: schema.sql
-
-OUTPUT FORMAT:

app/agents/base.py

@@ -1,91 +0,0 @@
-import json
-import httpx
-from typing import AsyncGenerator
-from app.config import settings
-
-
-class BaseAgent:
-    """Base class for all AI agents using OpenRouter API."""
-
-    role: str = ""
-    model_key: str = ""
-    system_prompt: str = ""
-    temperature: float = 0.7
-    max_tokens: int = 16000
-
-    @property
-    def model_id(self) -> str:
-        return settings.model_ids[self.model_key]
-
-    @property
-    def model_name(self) -> str:
-        return settings.model_names[self.model_key]
-
-    async def call(self, messages: list[dict], stream: bool = True) -> AsyncGenerator[str, None]:
-        """Call the model via OpenRouter, yielding streamed tokens."""
-        full_messages = [
-            {"role": "system", "content": self.system_prompt},
-            *messages,
-        ]
-        payload = {
-            "model": self.model_id,
-            "messages": full_messages,
-            "temperature": self.temperature,
-            "max_tokens": self.max_tokens,
-            "stream": stream,
-        }
-        headers = {
-            "Authorization": f"Bearer {settings.OPENROUTER_API_KEY}",
-            "Content-Type": "application/json",
-            "HTTP-Referer": "https://huggingface.co/spaces/nexus-builder",
-            "X-Title": "Nexus Builder",
-        }
-
-        if stream:
-            async with httpx.AsyncClient(timeout=settings.STREAM_TIMEOUT) as client:
-                async with client.stream(
-                    "POST",
-                    settings.OPENROUTER_BASE_URL,
-                    json=payload,
-                    headers=headers,
-                ) as response:
-                    if response.status_code != 200:
-                        body = await response.aread()
-                        raise Exception(
-                            f"OpenRouter error {response.status_code}: {body.decode()}"
-                        )
-                    async for line in response.aiter_lines():
-                        if not line.startswith("data: "):
-                            continue
-                        data_str = line[6:]
-                        if data_str.strip() == "[DONE]":
-                            break
-                        try:
-                            chunk = json.loads(data_str)
-                            delta = chunk["choices"][0].get("delta", {})
-                            content = delta.get("content", "")
-                            if content:
-                                yield content
-                        except (json.JSONDecodeError, KeyError, IndexError):
-                            continue
-        else:
-            async with httpx.AsyncClient(timeout=settings.STREAM_TIMEOUT) as client:
-                response = await client.post(
-                    settings.OPENROUTER_BASE_URL,
-                    json=payload,
-                    headers=headers,
-                )
-                if response.status_code != 200:
-                    raise Exception(
-                        f"OpenRouter error {response.status_code}: {response.text}"
-                    )
-                data = response.json()
-                content = data["choices"][0]["message"]["content"]
-                yield content
-
-    async def call_full(self, messages: list[dict]) -> str:
-        """Non-streaming call that returns the full response."""
-        result = []
-        async for token in self.call(messages, stream=False):
-            result.append(token)
-        return "".join(result)

app/agents/frontend_gen.py

@@ -1,60 +0,0 @@
-
----
-
-## FILE: `app/agents/frontend_gen.py`
-
-```python
-from app.agents.base import BaseAgent
-
-
-class FrontendAgent(BaseAgent):
-    role = "frontend"
-    model_key = "frontend"
-    temperature = 0.6
-    max_tokens = 32000
-    system_prompt = """You are the FRONTEND CODE GENERATION AGENT for Nexus Builder.
-
-YOUR ROLE: Generate complete, production-ready frontend code for web applications based on a blueprint.
-
-TECH STACK (always use):
-- React 18+ with functional components and hooks
-- Tailwind CSS for styling
-- React Router v6 for routing
-- Supabase JS client (@supabase/supabase-js) for auth & database
-- @paypal/react-paypal-js for payment integration
-- Recharts for analytics charts
-- Lucide React for icons
-
-DESIGN SYSTEM (always follow):
-Dark Mode Colors:
-- Background: #0A0A0F
-- Surface/Cards: #111118
-- Borders: #1E1E2E
-- Primary accent: #6C63FF (electric purple)
-- Secondary accent: #00D9FF (cyan)
-- Text primary: #F0F0FF
-- Text secondary: #8888AA
-- Success: #22D3A8
-- Error: #FF4D6D
-- Warning: #FFB547
-
-Light Mode Colors:
-- Background: #F8F8FC
-- Surface: #FFFFFF
-- Borders: #E0E0EF
-- Primary accent: #5B53E8
-- Text primary: #0A0A1A
-- Text secondary: #666688
-
-RULES:
-1. Generate COMPLETE files — no placeholders, no "// ... rest of code", no truncation
-2. Every component must be fully functional with proper state management
-3. Use CSS variables for theming (dark/light mode toggle)
-4. Mobile-first responsive design
-5. Smooth animations and transitions (CSS transitions, not heavy libraries)
-6. Accessible markup (semantic HTML, ARIA labels, keyboard navigation)
-7. Error boundaries and loading states for all async operations
-8. Each file must be clearly marked with its path using: // FILE: path/to/file.jsx
-
-OUTPUT FORMAT:
-For each file, output:

app/agents/orchestrator.py

@@ -1,100 +0,0 @@
-from app.agents.base import BaseAgent
-
-
-class OrchestratorAgent(BaseAgent):
-    role = "orchestrator"
-    model_key = "orchestrator"
-    temperature = 0.5
-    max_tokens = 24000
-    system_prompt = """You are the MASTER ORCHESTRATOR for Nexus Builder. You are the brain of the system.
-
-YOUR ROLE: Take the user's app description + research data and produce a comprehensive app blueprint that frontend and backend agents will use to generate code.
-
-You must produce a MASTER BLUEPRINT in JSON format containing:
-
-## Blueprint Structure:
-
-```json
-{
-  "project_name": "string",
-  "description": "string",
-  "systems": {
-    "client_portal": {
-      "pages": [
-        {
-          "path": "/dashboard",
-          "title": "Dashboard",
-          "components": ["Sidebar", "StatsCards", "RecentActivity", "QuickActions"],
-          "description": "Main user dashboard showing project overview",
-          "auth_required": true,
-          "role_required": "user"
-        }
-      ],
-      "features": ["auth", "project_management", "billing", "settings"]
-    },
-    "public_landing": {
-      "pages": [...],
-      "features": ["hero", "pricing", "features", "signup", "seo"]
-    },
-    "marketing_cms": {
-      "pages": [...],
-      "features": ["blog_editor", "email_capture", "campaigns"]
-    },
-    "analytics_dashboard": {
-      "pages": [...],
-      "features": ["realtime_metrics", "charts", "user_tracking", "revenue"]
-    },
-    "admin_panel": {
-      "pages": [...],
-      "features": ["user_management", "moderation", "system_health", "logs"]
-    }
-  },
-  "database_schema": {
-    "tables": [
-      {
-        "name": "profiles",
-        "columns": [
-          {"name": "id", "type": "uuid", "primary": true, "references": "auth.users.id"},
-          {"name": "full_name", "type": "text"},
-          {"name": "role", "type": "text", "default": "user"},
-          {"name": "created_at", "type": "timestamptz", "default": "now()"}
-        ],
-        "rls_policies": [
-          {"name": "Users read own profile", "operation": "SELECT", "check": "auth.uid() = id"}
-        ]
-      }
-    ]
-  },
-  "api_endpoints": [
-    {"method": "POST", "path": "/api/auth/signup", "description": "Register new user"},
-    {"method": "POST", "path": "/api/payments/create-order", "description": "Create PayPal order"}
-  ],
-  "auth_config": {
-    "providers": ["email", "google", "github"],
-    "jwt_expiry": 3600,
-    "refresh_enabled": true
-  },
-  "payment_config": {
-    "provider": "paypal",
-    "plans": [
-      {"name": "Free", "price": 0, "features": ["1 project", "Basic analytics"]},
-      {"name": "Pro", "price": 29, "features": ["Unlimited projects", "Advanced analytics", "Priority support"]},
-      {"name": "Enterprise", "price": 99, "features": ["Everything in Pro", "Custom integrations", "SLA"]}
-    ]
-  },
-  "design_tokens": {
-    "colors": {
-      "primary": "#6C63FF",
-      "secondary": "#00D9FF",
-      "background": "#0A0A0F",
-      "surface": "#111118",
-      "text": "#F0F0FF"
-    },
-    "fonts": {
-      "heading": "Inter",
-      "body": "Inter",
-      "mono": "JetBrains Mono"
-    },
-    "border_radius": "12px"
-  }
-}

app/agents/research.py

@@ -1,31 +0,0 @@
-from app.agents.base import BaseAgent
-
-
-class ResearchAgent(BaseAgent):
-    role = "research"
-    model_key = "research"
-    temperature = 0.4
-    max_tokens = 8000
-    system_prompt = """You are the RESEARCH AGENT for Nexus Builder, an AI-powered web application generator.
-
-YOUR ROLE: Gather and synthesize technical knowledge to inform the app-building pipeline.
-
-When given a user's app idea, you must produce a structured JSON research report covering:
-
-1. **stack_recommendation**: Recommend the optimal frontend framework (React/Next.js), CSS approach (Tailwind), backend (FastAPI/Express), database (Supabase), and deployment target (Firebase Hosting).
-
-2. **schema_hints**: Suggest database tables, columns, and relationships relevant to this app type. Include Supabase-specific features like RLS policies, realtime subscriptions, and Edge Functions.
-
-3. **api_docs_summary**: Summarize the key API endpoints needed. Include PayPal integration endpoints (Orders API v2, Subscriptions API), Supabase Auth endpoints, and any domain-specific APIs.
-
-4. **security_notes**: List security best practices for this app type — authentication flows, input validation, CORS configuration, rate limiting, SQL injection prevention, XSS prevention.
-
-5. **hosting_notes**: Firebase Hosting configuration tips, environment variable management, Docker deployment considerations.
-
-6. **ui_patterns**: Recommend UI patterns, component structures, and UX flows that work well for this type of application.
-
-7. **competitor_analysis**: Brief analysis of similar apps and what features users expect.
-
-ALWAYS respond with valid JSON wrapped in ```json code blocks. Be thorough but concise.
-Keep recommendations modern (2024-2025 best practices).
-Prioritize: Supabase for DB/Auth, PayPal for payments, React+Tailwind for frontend, FastAPI for backend."""

app/config.py

@@ -1,29 +0,0 @@
-import os
-from dotenv import load_dotenv
-
-load_dotenv()
-
-
-class Settings:
-    OPENROUTER_API_KEY: str = os.getenv("OPENROUTER_API_KEY", "")
-    OPENROUTER_BASE_URL: str = "https://openrouter.ai/api/v1/chat/completions"
-
-    model_ids = {
-        "research": "z-ai/glm-4.5-air:free",
-        "orchestrator": "arcee-ai/trinity-large-preview:free",
-        "frontend": "qwen/qwen3-coder:free",
-        "backend": "minimax/minimax-m2.5:free",
-    }
-
-    model_names = {
-        "research": "GLM 4.5 Air",
-        "orchestrator": "Trinity Large Preview",
-        "frontend": "Qwen3 Coder 480B",
-        "backend": "MiniMax M2.5",
-    }
-
-    MAX_RETRIES: int = 3
-    STREAM_TIMEOUT: int = 120
-
-
-settings = Settings()

app/main.py

@@ -1,249 +0,0 @@
-import os
-import json
-import uuid
-import asyncio
-import shutil
-import zipfile
-from pathlib import Path
-from contextlib import asynccontextmanager
-
-from fastapi import FastAPI, Request, HTTPException, BackgroundTasks
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import (
-    FileResponse, JSONResponse, StreamingResponse, HTMLResponse
-)
-from fastapi.middleware.cors import CORSMiddleware
-from sse_starlette.sse import EventSourceResponse
-
-from app.config import settings
-from app.models.schemas import (
-    GenerateRequest, FixRequest, ProjectState, AgentMessage
-)
-from app.pipeline.engine import PipelineEngine
-
-# ── Global State ──────────────────────────────────────────────
-sessions: dict[str, ProjectState] = {}
-pipeline_engine = PipelineEngine()
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    Path("/tmp/nexus_projects").mkdir(parents=True, exist_ok=True)
-    Path("/tmp/nexus_previews").mkdir(parents=True, exist_ok=True)
-    yield
-    # cleanup on shutdown if desired
-
-
-app = FastAPI(
-    title="Nexus Builder API",
-    version="1.0.0",
-    lifespan=lifespan,
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-# ── API Routes ────────────────────────────────────────────────
-
-@app.post("/api/generate")
-async def generate_project(req: GenerateRequest):
-    """Start a new project generation pipeline."""
-    session_id = str(uuid.uuid4())[:12]
-    project_dir = Path(f"/tmp/nexus_projects/{session_id}")
-    project_dir.mkdir(parents=True, exist_ok=True)
-    (project_dir / "frontend").mkdir(exist_ok=True)
-    (project_dir / "backend").mkdir(exist_ok=True)
-
-    state = ProjectState(
-        session_id=session_id,
-        user_prompt=req.prompt,
-        app_type=req.app_type or "saas",
-        status="queued",
-        project_dir=str(project_dir),
-        systems=req.systems or [
-            "client_portal", "public_landing",
-            "marketing_cms", "analytics_dashboard", "admin_panel"
-        ],
-    )
-    sessions[session_id] = state
-    # Pipeline runs in background; client listens via SSE
-    asyncio.create_task(pipeline_engine.run(state, sessions))
-    return {"session_id": session_id, "status": "started"}
-
-
-@app.get("/api/stream/{session_id}")
-async def stream_events(request: Request, session_id: str):
-    """SSE endpoint for real-time agent updates."""
-    if session_id not in sessions:
-        raise HTTPException(404, "Session not found")
-
-    async def event_generator():
-        state = sessions[session_id]
-        last_idx = 0
-        while True:
-            if await request.is_disconnected():
-                break
-            messages = state.messages[last_idx:]
-            for msg in messages:
-                yield {
-                    "event": msg.event_type,
-                    "data": json.dumps(msg.model_dump(), default=str),
-                }
-            last_idx = len(state.messages)
-            if state.status in ("completed", "error"):
-                yield {
-                    "event": "done",
-                    "data": json.dumps({
-                        "status": state.status,
-                        "session_id": session_id,
-                    }),
-                }
-                break
-            await asyncio.sleep(0.3)
-
-    return EventSourceResponse(event_generator())
-
-
-@app.get("/api/status/{session_id}")
-async def get_status(session_id: str):
-    if session_id not in sessions:
-        raise HTTPException(404, "Session not found")
-    state = sessions[session_id]
-    return {
-        "session_id": session_id,
-        "status": state.status,
-        "current_agent": state.current_agent,
-        "file_tree": state.file_tree,
-        "errors": state.errors,
-    }
-
-
-@app.get("/api/files/{session_id}")
-async def get_files(session_id: str):
-    """Return the generated file tree with contents."""
-    if session_id not in sessions:
-        raise HTTPException(404, "Session not found")
-    state = sessions[session_id]
-    return {"files": state.generated_files}
-
-
-@app.get("/api/file/{session_id}/{path:path}")
-async def get_file_content(session_id: str, path: str):
-    if session_id not in sessions:
-        raise HTTPException(404, "Session not found")
-    state = sessions[session_id]
-    content = state.generated_files.get(path)
-    if content is None:
-        raise HTTPException(404, "File not found")
-    return {"path": path, "content": content}
-
-
-@app.post("/api/fix/{session_id}")
-async def fix_bug(session_id: str, req: FixRequest):
-    """Send a bug report through the pipeline for targeted fixing."""
-    if session_id not in sessions:
-        raise HTTPException(404, "Session not found")
-    state = sessions[session_id]
-    state.status = "fixing"
-    asyncio.create_task(pipeline_engine.fix(state, req.error_message, req.file_path))
-    return {"status": "fix_started"}
-
-
-@app.get("/api/export/{session_id}")
-async def export_project(session_id: str):
-    """Export the generated project as a ZIP file."""
-    if session_id not in sessions:
-        raise HTTPException(404, "Session not found")
-    state = sessions[session_id]
-    zip_path = Path(f"/tmp/nexus_projects/{session_id}.zip")
-    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
-        for file_path, content in state.generated_files.items():
-            zf.writestr(file_path, content)
-    return FileResponse(
-        zip_path,
-        filename=f"nexus-project-{session_id}.zip",
-        media_type="application/zip",
-    )
-
-
-@app.get("/api/preview/{session_id}")
-async def preview_landing(session_id: str):
-    """Serve a combined preview HTML of the generated app."""
-    if session_id not in sessions:
-        raise HTTPException(404, "Session not found")
-    state = sessions[session_id]
-    # Look for index.html in generated files
-    for key in [
-        "frontend/index.html",
-        "public_landing/index.html",
-        "client_portal/index.html",
-        "index.html",
-    ]:
-        if key in state.generated_files:
-            return HTMLResponse(state.generated_files[key])
-    # Build a combined preview
-    html = _build_combined_preview(state)
-    return HTMLResponse(html)
-
-
-@app.get("/api/preview/{session_id}/{system}")
-async def preview_system(session_id: str, system: str):
-    if session_id not in sessions:
-        raise HTTPException(404, "Session not found")
-    state = sessions[session_id]
-    key = f"{system}/index.html"
-    if key in state.generated_files:
-        return HTMLResponse(state.generated_files[key])
-    html = _build_system_preview(state, system)
-    return HTMLResponse(html)
-
-
-def _build_combined_preview(state: ProjectState) -> str:
-    pages = []
-    for path, content in state.generated_files.items():
-        if path.endswith(".html"):
-            pages.append(f"<!-- {path} -->\n{content}")
-    if not pages:
-        return "<html><body style='background:#0A0A0F;color:#F0F0FF;font-family:sans-serif;display:flex;align-items:center;justify-content:center;height:100vh'><h1>⏳ Preview will appear here once generation completes</h1></body></html>"
-    return pages[0]
-
-
-def _build_system_preview(state: ProjectState, system: str) -> str:
-    system_files = {
-        k: v for k, v in state.generated_files.items()
-        if k.startswith(f"{system}/")
-    }
-    for path, content in system_files.items():
-        if path.endswith(".html"):
-            return content
-    return f"<html><body style='background:#0A0A0F;color:#F0F0FF;font-family:sans-serif;padding:40px'><h1>System: {system}</h1><p>No preview available yet.</p></body></html>"
-
-
-@app.get("/api/health")
-async def health():
-    return {"status": "ok", "models": settings.model_ids}
-
-
-# ── Serve Frontend ────────────────────────────────────────────
-static_dir = Path("/app/static")
-if static_dir.exists():
-    app.mount("/assets", StaticFiles(directory=static_dir / "assets"), name="assets")
-
-    @app.get("/{path:path}")
-    async def serve_frontend(path: str):
-        file_path = static_dir / path
-        if file_path.is_file():
-            return FileResponse(file_path)
-        return FileResponse(static_dir / "index.html")
-else:
-    @app.get("/")
-    async def root():
-        return HTMLResponse(
-            "<h1>Nexus Builder</h1><p>Frontend not built. Run npm build in /frontend</p>"
-        )

app/models/__init__.py

@@ -1 +0,0 @@
-undefined

app/models/schemas.py

@@ -1,43 +0,0 @@
-from __future__ import annotations
-from pydantic import BaseModel, Field
-from typing import Optional
-from datetime import datetime
-
-
-class GenerateRequest(BaseModel):
-    prompt: str
-    app_type: Optional[str] = "saas"
-    systems: Optional[list[str]] = None
-
-
-class FixRequest(BaseModel):
-    error_message: str
-    file_path: Optional[str] = None
-
-
-class AgentMessage(BaseModel):
-    event_type: str  # agent_start, token, code_block, agent_done, error, file_created
-    agent: str       # research, orchestrator, frontend, backend, system
-    content: str = ""
-    file_path: Optional[str] = None
-    timestamp: datetime = Field(default_factory=datetime.utcnow)
-    metadata: dict = Field(default_factory=dict)
-
-
-class ProjectState(BaseModel):
-    session_id: str
-    user_prompt: str
-    app_type: str = "saas"
-    status: str = "queued"  # queued, researching, orchestrating, building_frontend, building_backend, merging, completed, error, fixing
-    current_agent: str = ""
-    project_dir: str = ""
-    systems: list[str] = Field(default_factory=list)
-    messages: list[AgentMessage] = Field(default_factory=list)
-    generated_files: dict[str, str] = Field(default_factory=dict)
-    file_tree: list[str] = Field(default_factory=list)
-    errors: list[str] = Field(default_factory=list)
-    research_output: dict = Field(default_factory=dict)
-    blueprint: dict = Field(default_factory=dict)
-
-    class Config:
-        arbitrary_types_allowed = True

app/pipeline/__init__.py

@@ -1 +0,0 @@
-undefined

app/pipeline/engine.py

@@ -1,555 +0,0 @@
-import json
-import re
-import asyncio
-import traceback
-from datetime import datetime
-
-from app.agents import (
-    ResearchAgent, OrchestratorAgent, FrontendAgent, BackendAgent
-)
-from app.models.schemas import ProjectState, AgentMessage
-
-
-class PipelineEngine:
-    """Orchestrates the 4-agent pipeline for project generation."""
-
-    def __init__(self):
-        self.research_agent = ResearchAgent()
-        self.orchestrator_agent = OrchestratorAgent()
-        self.frontend_agent = FrontendAgent()
-        self.backend_agent = BackendAgent()
-
-    def _emit(self, state: ProjectState, event_type: str, agent: str,
-              content: str = "", file_path: str | None = None, metadata: dict | None = None):
-        msg = AgentMessage(
-            event_type=event_type,
-            agent=agent,
-            content=content,
-            file_path=file_path,
-            metadata=metadata or {},
-        )
-        state.messages.append(msg)
-
-    async def run(self, state: ProjectState, sessions: dict):
-        """Execute the full 4-agent pipeline."""
-        try:
-            # ── Phase 1: Research ──────────────────────────────
-            state.status = "researching"
-            state.current_agent = "research"
-            self._emit(state, "agent_start", "research",
-                       "🔍 Starting research phase...")
-
-            research_output = await self._run_research(state)
-            state.research_output = research_output
-
-            self._emit(state, "agent_done", "research",
-                       "✅ Research complete",
-                       metadata={"summary": str(research_output)[:500]})
-
-            # ── Phase 2: Orchestration ─────────────────────────
-            state.status = "orchestrating"
-            state.current_agent = "orchestrator"
-            self._emit(state, "agent_start", "orchestrator",
-                       "🧠 Creating master blueprint...")
-
-            blueprint = await self._run_orchestrator(state)
-            state.blueprint = blueprint
-
-            self._emit(state, "agent_done", "orchestrator",
-                       "✅ Blueprint created",
-                       metadata={"systems": list(blueprint.get("systems", {}).keys())})
-
-            # ── Phase 3 & 4: Frontend + Backend (parallel) ─────
-            state.status = "building"
-            self._emit(state, "agent_start", "system",
-                       "🚀 Starting parallel code generation...")
-
-            state.current_agent = "frontend+backend"
-            await asyncio.gather(
-                self._run_frontend(state),
-                self._run_backend(state),
-            )
-
-            # ── Phase 5: Merge & Finalize ──────────────────────
-            state.status = "merging"
-            state.current_agent = "system"
-            self._emit(state, "agent_start", "system",
-                       "📦 Merging outputs and building preview...")
-
-            self._build_file_tree(state)
-            self._generate_combined_preview(state)
-
-            state.status = "completed"
-            state.current_agent = ""
-            self._emit(state, "agent_done", "system",
-                       f"🎉 Project complete! {len(state.generated_files)} files generated.")
-
-        except Exception as e:
-            state.status = "error"
-            state.errors.append(str(e))
-            self._emit(state, "error", state.current_agent or "system",
-                       f"❌ Error: {str(e)}",
-                       metadata={"traceback": traceback.format_exc()})
-
-    async def _run_research(self, state: ProjectState) -> dict:
-        prompt = f"""Research the following app idea and produce a comprehensive technical report:
-
-APP IDEA: {state.user_prompt}
-APP TYPE: {state.app_type}
-REQUIRED SYSTEMS: {', '.join(state.systems)}
-
-Produce your report as a JSON object with keys: stack_recommendation, schema_hints, api_docs_summary, security_notes, hosting_notes, ui_patterns, competitor_analysis"""
-
-        full_response = []
-        async for token in self.research_agent.call(
-            [{"role": "user", "content": prompt}], stream=True
-        ):
-            full_response.append(token)
-            if len(full_response) % 20 == 0:
-                self._emit(state, "token", "research", token)
-
-        text = "".join(full_response)
-        self._emit(state, "token", "research", "\n[Research output received]")
-
-        # Parse JSON from response
-        return self._extract_json(text)
-
-    async def _run_orchestrator(self, state: ProjectState) -> dict:
-        prompt = f"""Create a master blueprint for this application:
-
-USER REQUEST: {state.user_prompt}
-APP TYPE: {state.app_type}
-SYSTEMS TO BUILD: {', '.join(state.systems)}
-
-RESEARCH DATA:
-{json.dumps(state.research_output, indent=2, default=str)[:8000]}
-
-Generate the complete master blueprint as a JSON object following the exact structure from your instructions. Customize everything for this specific app idea."""
-
-        full_response = []
-        async for token in self.orchestrator_agent.call(
-            [{"role": "user", "content": prompt}], stream=True
-        ):
-            full_response.append(token)
-            if len(full_response) % 15 == 0:
-                self._emit(state, "token", "orchestrator", token)
-
-        text = "".join(full_response)
-        return self._extract_json(text)
-
-    async def _run_frontend(self, state: ProjectState):
-        self._emit(state, "agent_start", "frontend",
-                   "🎨 Generating frontend code...")
-
-        for system in state.systems:
-            system_blueprint = state.blueprint.get("systems", {}).get(system, {})
-            design_tokens = state.blueprint.get("design_tokens", {})
-            payment_config = state.blueprint.get("payment_config", {})
-
-            prompt = f"""Generate the complete frontend code for the "{system}" system.
-
-SYSTEM BLUEPRINT:
-{json.dumps(system_blueprint, indent=2, default=str)}
-
-DESIGN TOKENS:
-{json.dumps(design_tokens, indent=2, default=str)}
-
-PAYMENT CONFIG:
-{json.dumps(payment_config, indent=2, default=str)}
-
-DATABASE SCHEMA (for reference):
-{json.dumps(state.blueprint.get('database_schema', {}), indent=2, default=str)[:4000]}
-
-Generate ALL files needed for this system. Use React + Tailwind CSS.
-Include: all page components, shared components, routing, Supabase client setup, theme system.
-Mark each file with: // FILE: {system}/src/ComponentName.jsx
-
-The app should look premium with the specified dark mode colors. Include animations and responsive design."""
-
-            full_response = []
-            async for token in self.frontend_agent.call(
-                [{"role": "user", "content": prompt}], stream=True
-            ):
-                full_response.append(token)
-                if len(full_response) % 10 == 0:
-                    self._emit(state, "token", "frontend", token)
-
-            text = "".join(full_response)
-            files = self._extract_files(text)
-
-            for path, content in files.items():
-                state.generated_files[path] = content
-                self._emit(state, "file_created", "frontend",
-                           f"Created {path}", file_path=path)
-
-        self._emit(state, "agent_done", "frontend",
-                   f"✅ Frontend generation complete")
-
-    async def _run_backend(self, state: ProjectState):
-        self._emit(state, "agent_start", "backend",
-                   "🔐 Generating backend code...")
-
-        db_schema = state.blueprint.get("database_schema", {})
-        api_endpoints = state.blueprint.get("api_endpoints", [])
-        auth_config = state.blueprint.get("auth_config", {})
-        payment_config = state.blueprint.get("payment_config", {})
-
-        prompt = f"""Generate the complete backend code for this application.
-
-DATABASE SCHEMA:
-{json.dumps(db_schema, indent=2, default=str)}
-
-API ENDPOINTS:
-{json.dumps(api_endpoints, indent=2, default=str)}
-
-AUTH CONFIG:
-{json.dumps(auth_config, indent=2, default=str)}
-
-PAYMENT CONFIG:
-{json.dumps(payment_config, indent=2, default=str)}
-
-APP DESCRIPTION: {state.user_prompt}
-
-Generate ALL files:
-1. Complete Supabase SQL schema (CREATE TABLE, RLS, triggers, indexes)
-2. FastAPI backend with all routes, auth middleware, PayPal integration
-3. Supabase Edge Functions (TypeScript)
-4. Docker configuration (Dockerfile, docker-compose.yml)
-5. Firebase hosting config
-6. .env.example
-7. DEPLOY.md with step-by-step deployment guide
-
-Mark each file clearly with: # FILE: backend/filename.py or -- FILE: database/schema.sql"""
-
-        full_response = []
-        async for token in self.backend_agent.call(
-            [{"role": "user", "content": prompt}], stream=True
-        ):
-            full_response.append(token)
-            if len(full_response) % 10 == 0:
-                self._emit(state, "token", "backend", token)
-
-        text = "".join(full_response)
-        files = self._extract_files(text)
-
-        for path, content in files.items():
-            state.generated_files[path] = content
-            self._emit(state, "file_created", "backend",
-                       f"Created {path}", file_path=path)
-
-        self._emit(state, "agent_done", "backend",
-                   "✅ Backend generation complete")
-
-    async def fix(self, state: ProjectState, error_message: str,
-                  file_path: str | None = None):
-        """Run a targeted bug fix through the appropriate agent."""
-        self._emit(state, "agent_start", "backend",
-                   f"🔧 Fixing bug: {error_message[:100]}...")
-
-        relevant_code = ""
-        if file_path and file_path in state.generated_files:
-            relevant_code = state.generated_files[file_path]
-
-        prompt = f"""FIX THIS BUG:
-
-ERROR: {error_message}
-
-{"FILE: " + file_path if file_path else ""}
-{"CODE:" + chr(10) + relevant_code[:8000] if relevant_code else ""}
-
-Provide the COMPLETE fixed file content. Mark it with the original file path."""
-
-        # Determine which agent to use based on file type
-        if file_path and any(file_path.endswith(ext) for ext in [".jsx", ".tsx", ".css", ".html"]):
-            agent = self.frontend_agent
-            agent_name = "frontend"
-        else:
-            agent = self.backend_agent
-            agent_name = "backend"
-
-        full_response = []
-        async for token in agent.call(
-            [{"role": "user", "content": prompt}], stream=True
-        ):
-            full_response.append(token)
-
-        text = "".join(full_response)
-        files = self._extract_files(text)
-
-        for path, content in files.items():
-            state.generated_files[path] = content
-            self._emit(state, "file_created", agent_name,
-                       f"Fixed {path}", file_path=path)
-
-        state.status = "completed"
-        self._emit(state, "agent_done", agent_name, "✅ Bug fix applied")
-
-    def _extract_json(self, text: str) -> dict:
-        """Extract JSON from a model response that may contain markdown."""
-        # Try to find JSON in code blocks
-        patterns = [
-            r'```json\s*([\s\S]*?)\s*```',
-            r'```\s*([\s\S]*?)\s*```',
-            r'\{[\s\S]*\}',
-        ]
-        for pattern in patterns:
-            matches = re.findall(pattern, text)
-            for match in matches:
-                try:
-                    return json.loads(match)
-                except json.JSONDecodeError:
-                    continue
-
-        # If no valid JSON found, create a minimal structure
-        return {
-            "project_name": "generated-app",
-            "description": text[:200],
-            "systems": {
-                "client_portal": {"pages": [{"path": "/dashboard", "title": "Dashboard", "components": ["Layout", "Stats"], "auth_required": True}], "features": ["auth", "dashboard"]},
-                "public_landing": {"pages": [{"path": "/", "title": "Home", "components": ["Hero", "Features", "Pricing"], "auth_required": False}], "features": ["hero", "pricing"]},
-                "marketing_cms": {"pages": [{"path": "/blog", "title": "Blog", "components": ["BlogList", "Editor"], "auth_required": True}], "features": ["blog"]},
-                "analytics_dashboard": {"pages": [{"path": "/analytics", "title": "Analytics", "components": ["Charts", "Metrics"], "auth_required": True}], "features": ["charts"]},
-                "admin_panel": {"pages": [{"path": "/admin", "title": "Admin", "components": ["UserTable", "Settings"], "auth_required": True}], "features": ["user_management"]},
-            },
-            "database_schema": {"tables": []},
-            "api_endpoints": [],
-            "auth_config": {"providers": ["email"]},
-            "payment_config": {"provider": "paypal", "plans": []},
-            "design_tokens": {
-                "colors": {"primary": "#6C63FF", "secondary": "#00D9FF", "background": "#0A0A0F", "surface": "#111118", "text": "#F0F0FF"},
-                "fonts": {"heading": "Inter", "body": "Inter", "mono": "JetBrains Mono"},
-            },
-        }
-
-    def _extract_files(self, text: str) -> dict[str, str]:
-        """Extract file contents from model output marked with FILE: comments."""
-        files = {}
-        # Match patterns like: // FILE: path/to/file.jsx  or  # FILE: path/to/file.py  or  -- FILE: path/to/file.sql
-        pattern = r'(?://|#|--)\s*FILE:\s*(.+?)(?:\n)([\s\S]*?)(?=(?://|#|--)\s*FILE:|$)'
-        matches = re.findall(pattern, text)
-
-        if matches:
-            for file_path, content in matches:
-                path = file_path.strip()
-                # Clean content — remove trailing code block markers
-                content = re.sub(r'\s*```\s*$', '', content.strip())
-                content = re.sub(r'^```\w*\s*', '', content.strip())
-                files[path] = content.strip()
-        else:
-            # Fallback: try to extract from code blocks with filenames
-            code_blocks = re.findall(
-                r'(?:#+\s*)?(?:`([^`]+)`|(\S+\.\w+))\s*\n```\w*\n([\s\S]*?)```',
-                text
-            )
-            for name1, name2, content in code_blocks:
-                name = name1 or name2
-                if name and content.strip():
-                    files[name.strip()] = content.strip()
-
-        # If still no files extracted, save as raw output
-        if not files:
-            if "def " in text or "import " in text:
-                files["backend/generated_output.py"] = text
-            elif "function " in text or "const " in text or "import " in text:
-                files["frontend/generated_output.jsx"] = text
-            elif "CREATE TABLE" in text.upper():
-                files["database/schema.sql"] = text
-            else:
-                files["output/raw_output.txt"] = text
-
-        return files
-
-    def _build_file_tree(self, state: ProjectState):
-        """Build a sorted file tree from generated files."""
-        state.file_tree = sorted(state.generated_files.keys())
-
-    def _generate_combined_preview(self, state: ProjectState):
-        """Generate a combined HTML preview page for the app."""
-        design = state.blueprint.get("design_tokens", {})
-        colors = design.get("colors", {})
-        project_name = state.blueprint.get("project_name", "Generated App")
-        systems = state.blueprint.get("systems", {})
-
-        system_cards = ""
-        for sys_name, sys_data in systems.items():
-            pages = sys_data.get("pages", [])
-            features = sys_data.get("features", [])
-            page_list = "".join(
-                f'<li>{p.get("title", p.get("path", "Page"))}</li>'
-                for p in pages[:5]
-            )
-            feature_list = "".join(f'<span class="tag">{f}</span>' for f in features[:6])
-            nice_name = sys_name.replace("_", " ").title()
-            system_cards += f"""
-            <div class="system-card">
-                <h3>{nice_name}</h3>
-                <div class="tags">{feature_list}</div>
-                <ul>{page_list}</ul>
-                <div class="page-count">{len(pages)} pages</div>
-            </div>"""
-
-        file_count = len(state.generated_files)
-        file_types = {}
-        for f in state.generated_files:
-            ext = f.rsplit(".", 1)[-1] if "." in f else "other"
-            file_types[ext] = file_types.get(ext, 0) + 1
-        file_stats = " • ".join(f"{count} .{ext}" for ext, count in sorted(file_types.items()))
-
-        preview_html = f"""<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>{project_name} — Preview</title>
-    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
-    <style>
-        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
-        body {{
-            font-family: 'Inter', sans-serif;
-            background: {colors.get('background', '#0A0A0F')};
-            color: {colors.get('text', '#F0F0FF')};
-            min-height: 100vh;
-            padding: 2rem;
-        }}
-        .container {{ max-width: 1200px; margin: 0 auto; }}
-        .hero {{
-            text-align: center;
-            padding: 4rem 2rem;
-            background: linear-gradient(135deg, {colors.get('surface', '#111118')} 0%, {colors.get('background', '#0A0A0F')} 100%);
-            border-radius: 24px;
-            border: 1px solid #1E1E2E;
-            margin-bottom: 2rem;
-        }}
-        .hero h1 {{
-            font-size: 3rem;
-            font-weight: 700;
-            background: linear-gradient(135deg, {colors.get('primary', '#6C63FF')}, {colors.get('secondary', '#00D9FF')});
-            -webkit-background-clip: text;
-            -webkit-text-fill-color: transparent;
-            margin-bottom: 1rem;
-        }}
-        .hero p {{ color: #8888AA; font-size: 1.2rem; max-width: 600px; margin: 0 auto; }}
-        .stats {{
-            display: flex;
-            gap: 1rem;
-            justify-content: center;
-            margin-top: 2rem;
-            flex-wrap: wrap;
-        }}
-        .stat {{
-            background: #111118;
-            border: 1px solid #1E1E2E;
-            border-radius: 12px;
-            padding: 1rem 1.5rem;
-            text-align: center;
-        }}
-        .stat-value {{
-            font-size: 2rem;
-            font-weight: 700;
-            color: {colors.get('primary', '#6C63FF')};
-        }}
-        .stat-label {{ color: #8888AA; font-size: 0.85rem; margin-top: 0.25rem; }}
-        .systems-grid {{
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
-            gap: 1.5rem;
-            margin-top: 2rem;
-        }}
-        .system-card {{
-            background: #111118;
-            border: 1px solid #1E1E2E;
-            border-radius: 16px;
-            padding: 1.5rem;
-            transition: all 0.3s ease;
-        }}
-        .system-card:hover {{
-            border-color: {colors.get('primary', '#6C63FF')}44;
-            transform: translateY(-2px);
-            box-shadow: 0 8px 32px {colors.get('primary', '#6C63FF')}11;
-        }}
-        .system-card h3 {{
-            font-size: 1.2rem;
-            font-weight: 600;
-            margin-bottom: 0.75rem;
-            color: {colors.get('text', '#F0F0FF')};
-        }}
-        .tags {{ display: flex; flex-wrap: wrap; gap: 0.4rem; margin-bottom: 1rem; }}
-        .tag {{
-            background: {colors.get('primary', '#6C63FF')}22;
-            color: {colors.get('primary', '#6C63FF')};
-            padding: 0.2rem 0.6rem;
-            border-radius: 6px;
-            font-size: 0.75rem;
-            font-weight: 500;
-        }}
-        ul {{ list-style: none; margin-bottom: 0.75rem; }}
-        li {{
-            padding: 0.3rem 0;
-            color: #8888AA;
-            font-size: 0.9rem;
-            border-bottom: 1px solid #1E1E2E;
-        }}
-        li:last-child {{ border-bottom: none; }}
-        .page-count {{
-            color: {colors.get('secondary', '#00D9FF')};
-            font-size: 0.8rem;
-            font-weight: 500;
-        }}
-        .file-info {{
-            text-align: center;
-            margin-top: 2rem;
-            padding: 1rem;
-            color: #8888AA;
-            font-family: 'JetBrains Mono', monospace;
-            font-size: 0.85rem;
-        }}
-        .section-title {{
-            font-size: 1.5rem;
-            font-weight: 600;
-            margin-bottom: 0.5rem;
-        }}
-        @keyframes fadeIn {{
-            from {{ opacity: 0; transform: translateY(10px); }}
-            to {{ opacity: 1; transform: translateY(0); }}
-        }}
-        .system-card {{ animation: fadeIn 0.5s ease forwards; }}
-        .system-card:nth-child(2) {{ animation-delay: 0.1s; }}
-        .system-card:nth-child(3) {{ animation-delay: 0.2s; }}
-        .system-card:nth-child(4) {{ animation-delay: 0.3s; }}
-        .system-card:nth-child(5) {{ animation-delay: 0.4s; }}
-    </style>
-</head>
-<body>
-    <div class="container">
-        <div class="hero">
-            <h1>{project_name}</h1>
-            <p>{state.user_prompt[:200]}</p>
-            <div class="stats">
-                <div class="stat">
-                    <div class="stat-value">{len(systems)}</div>
-                    <div class="stat-label">Systems</div>
-                </div>
-                <div class="stat">
-                    <div class="stat-value">{file_count}</div>
-                    <div class="stat-label">Files Generated</div>
-                </div>
-                <div class="stat">
-                    <div class="stat-value">{sum(len(s.get('pages',[])) for s in systems.values())}</div>
-                    <div class="stat-label">Total Pages</div>
-                </div>
-            </div>
-        </div>
-
-        <h2 class="section-title">Generated Systems</h2>
-        <div class="systems-grid">
-            {system_cards}
-        </div>
-
-        <div class="file-info">
-            {file_stats}
-        </div>
-    </div>
-</body>
-</html>"""
-
-        state.generated_files["preview/index.html"] = preview_html

app/preview/__init__.py

@@ -1 +0,0 @@
-undefined

app/preview/builder.py

@@ -1,45 +0,0 @@
-"""Preview builder utilities — generates live previews of generated apps."""
-
-import subprocess
-from pathlib import Path
-
-
-def build_frontend_preview(project_dir: str, session_id: str) -> str | None:
-    """Attempt to build a frontend project for live preview.
-
-    Returns the path to built files, or None if build is not possible
-    (e.g., no package.json, or npm not available on CPU tier).
-    """
-    frontend_dir = Path(project_dir) / "frontend"
-    package_json = frontend_dir / "package.json"
-
-    if not package_json.exists():
-        return None
-
-    try:
-        # Install deps
-        subprocess.run(
-            ["npm", "install"],
-            cwd=str(frontend_dir),
-            timeout=120,
-            capture_output=True,
-        )
-        # Build
-        result = subprocess.run(
-            ["npm", "run", "build"],
-            cwd=str(frontend_dir),
-            timeout=120,
-            capture_output=True,
-        )
-        if result.returncode == 0:
-            dist_dir = frontend_dir / "dist"
-            if dist_dir.exists():
-                preview_dir = f"/tmp/nexus_previews/{session_id}"
-                Path(preview_dir).mkdir(parents=True, exist_ok=True)
-                import shutil
-                shutil.copytree(str(dist_dir), preview_dir, dirs_exist_ok=True)
-                return preview_dir
-    except (subprocess.TimeoutExpired, FileNotFoundError):
-        pass
-
-    return None