Prepare Syntax AI for Hugging Face Space

.dockerignore

@@ -0,0 +1,7 @@
+.git
+__pycache__
+*.pyc
+.env
+frontend/node_modules
+frontend/build
+output.txt

Dockerfile

@@ -1,66 +1,31 @@
-# --- Stage 1: Build the React Frontend ---
-FROM node:18 AS build-stage
+FROM node:18 AS frontend-build
+
 WORKDIR /app/frontend
 COPY frontend/package*.json ./
-RUN npm install
+RUN npm ci
 COPY frontend/ ./
 RUN npm run build
 
-# --- Stage 2: Final Monolithic Image ---
 FROM python:3.11-slim
 
-# Install Node.js and Nginx
-RUN apt-get update && apt-get install -y \
-    curl \
-    nginx \
-    && curl -fsSL https://deb.nodesource.com/setup_18.x | bash - \
-    && apt-get install -y nodejs \
-    && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /app
-
-# 1. Setup Backend (Node.js)
-COPY frontend/package*.json ./backend/
-RUN cd backend && npm install --production
-COPY frontend/src/server.js ./backend/src/
-
-# 2. Setup AI Agent (Python)
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-COPY ai_agent.py server.py ./
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PORT=7860
 
-# 3. Setup Frontend (Static Files)
-COPY --from=build-stage /app/frontend/build /usr/share/nginx/html
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
 
-# 4. Nginx Configuration
-RUN echo 'server { \
-    listen 7860; \
-    location / { \
-        root /usr/share/nginx/html; \
-        index index.html; \
-        try_files $uri /index.html; \
-    } \
-    location /api/ { \
-        proxy_pass http://127.0.0.1:5003/; \
-        proxy_set_header Host $host; \
-    } \
-    location /process-request/ { \
-        proxy_pass http://127.0.0.1:8000/process-request; \
-        proxy_set_header Host $host; \
-    } \
-}' > /etc/nginx/sites-available/default
+WORKDIR /app
 
-# 5. Startup Script
-RUN echo '#!/bin/bash\n\
-python3 server.py & \n\
-node backend/src/server.js & \n\
-nginx -g "daemon off;"' > /app/start.sh
-RUN chmod +x /app/start.sh
+COPY --chown=user requirements.txt ./
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
 
-# Hugging Face Requirement: Non-root user with Port 7860
-# (HFS provides this user by default, but we'll ensure Nginx is ready)
-RUN chmod -R 777 /var/log/nginx /var/lib/nginx /run
+COPY --chown=user ai_agent.py server.py ./
+COPY --chown=user frontend ./frontend
+COPY --from=frontend-build --chown=user /app/frontend/build ./frontend/build
 
 EXPOSE 7860
 
-CMD ["/app/start.sh"]
+CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -40,10 +40,10 @@ Syntax AI includes a sophisticated reporting engine that visualizes the impact o
 The user interface is built on a custom design system that prioritizes clarity and visual depth. The "Galaxy Glass" aesthetic utilizes dynamic starfield simulations, advanced glassmorphism components, and subtle micro-animations to create a focused, premium workspace.
 
 ### Backend Infrastructure
-- **Python (FastAPI)**: Orchestrates AI inference and core logic.
+- **Python (FastAPI)**: Serves the React UI, orchestrates AI inference, and exposes the API routes.
 - **Phidata**: Manages multi-agent task distribution and state.
-- **Node.js (Express)**: Handles secure authentication and database persistence.
 - **Mistral AI**: Provides the underlying transformer architecture for code intelligence.
+- **PostgreSQL / Supabase (optional)**: Stores users and activity history when `DATABASE_URL` is configured.
 
 ### Frontend Implementation
 - **React.js**: Facilitates a responsive and component-driven user experience.
@@ -60,13 +60,13 @@ The user interface is built on a custom design system that prioritizes clarity a
 ### 1. Prerequisites
 - Python 3.10 or higher
 - Node.js (v18+) and npm
-- MySQL Server instance
+- Optional PostgreSQL / Supabase database
 
 ### 2. Environment Configuration
 Define local environment variables in a `.env` file at the root directory (see `.env.example` for details):
 ```env
 MISTRAL_API_KEY=your_secured_key
-DB_PASSWORD=your_mysql_credentials
+DATABASE_URL=postgresql://username:password@host:port/database
 ```
 
 ### 3. Dependency Installation
@@ -81,16 +81,28 @@ npm install
 
 ### 4. System Launch
 ```bash
-# Start AI Logic Server
+# Start the FastAPI server
 python server.py
 
-# Start Node Backend (located in /frontend/src)
-node server.js
-
-# Initialize React Application
+# In a separate terminal, start the React dev server
+cd frontend
 npm start
 ```
 
+### 5. Hugging Face Spaces
+This repository is configured for a Docker Space.
+
+Required secret:
+- `MISTRAL_API_KEY`
+
+Optional secret:
+- `DATABASE_URL`
+
+Notes:
+- The container exposes port `7860`, which matches the Space metadata.
+- If `DATABASE_URL` is not set, the app falls back to in-memory login and activity storage so the demo still runs.
+- The React app is built inside the Docker image and served by FastAPI from the same container.
+
 ---
 
 ## License
@@ -98,4 +110,4 @@ This project is released under the MIT License.
 
 ---
 
-Developed by [Hariprasath](https://github.com/Hariprasath-5128)
+Developed by [Hariprasath](https://github.com/Hariprasath-5128)

requirements.txt

@@ -1,7 +1,8 @@
 fastapi
-uvicorn
+uvicorn[standard]
 pydantic
 phidata==2.7.10
 mistralai==1.1.0
 python-dotenv
 requests
+psycopg[binary]

server.py

@@ -1,37 +1,325 @@
 import logging
+import os
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any
+
+from dotenv import load_dotenv
 from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
+
+try:
+    import psycopg
+except ImportError:  # pragma: no cover
+    psycopg = None
+
 from ai_agent import handle_task
 
+
+load_dotenv()
+
 logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+logger = logging.getLogger(__name__)
+
+BASE_DIR = Path(__file__).resolve().parent
+FRONTEND_BUILD_DIR = BASE_DIR / "frontend" / "build"
+DATABASE_URL = os.getenv("DATABASE_URL", "").strip()
 
 app = FastAPI(title="Syntax AI Server")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
 
 class RequestModel(BaseModel):
     taskType: str
     prompt: str
 
-# --- API Endpoint ---
+
+class AuthRequest(BaseModel):
+    username: str
+    password: str
+    action: str
+
+
+class StoreOptionRequest(BaseModel):
+    userId: int | None = None
+    option: str
+    language: str | None = None
+    codePrompt: str | None = None
+    modifyCode: str | None = None
+    modifyLogic: str | None = None
+
+
+class AnalyzeCodeRequest(BaseModel):
+    userId: int | None = None
+    originalCode: str
+    modifiedCode: str
+
+
+memory_users: dict[str, dict[str, Any]] = {}
+memory_activity: list[dict[str, Any]] = []
+memory_user_id = 0
+
+
+def has_database() -> bool:
+    return bool(DATABASE_URL and psycopg is not None)
+
+
+@contextmanager
+def get_db_connection():
+    if not has_database():
+        raise RuntimeError("DATABASE_URL is not configured.")
+    conn = psycopg.connect(DATABASE_URL)
+    try:
+        yield conn
+    finally:
+        conn.close()
+
+
+def setup_database() -> None:
+    if not has_database():
+        logger.warning("DATABASE_URL not set. Using in-memory auth and activity storage.")
+        return
+
+    try:
+        with get_db_connection() as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    """
+                    CREATE TABLE IF NOT EXISTS users (
+                        id SERIAL PRIMARY KEY,
+                        username TEXT NOT NULL UNIQUE,
+                        password TEXT NOT NULL
+                    )
+                    """
+                )
+                cur.execute(
+                    """
+                    CREATE TABLE IF NOT EXISTS user_activity (
+                        id SERIAL PRIMARY KEY,
+                        user_id INTEGER REFERENCES users(id) ON DELETE SET NULL,
+                        user_option TEXT,
+                        language TEXT,
+                        qn TEXT,
+                        modify_code_input TEXT,
+                        modify_code_logic TEXT,
+                        output TEXT,
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                    )
+                    """
+                )
+            conn.commit()
+        logger.info("Database tables are ready.")
+    except Exception:
+        logger.exception("Database initialization failed. Falling back to in-memory mode.")
+
+
+@app.on_event("startup")
+def on_startup() -> None:
+    setup_database()
+
+
+def run_ai_task(prompt: str) -> str:
+    result = handle_task(prompt)
+    if hasattr(result, "content"):
+        return str(result.content)
+    if isinstance(result, dict):
+        return str(result)
+    return str(result)
+
+
+def create_memory_user(username: str, password: str) -> int:
+    global memory_user_id
+    if username in memory_users:
+        raise ValueError("Username already exists.")
+    memory_user_id += 1
+    memory_users[username] = {"id": memory_user_id, "password": password}
+    return memory_user_id
+
 
 @app.post("/process-request")
+@app.post("/api/process-request")
 async def process_request(request: RequestModel):
     try:
-        # Get the result from AI
-        result = handle_task(request.prompt)
-        
-        # Convert result to string if it's not already
-        if hasattr(result, 'content'):
-            result_str = result.content
-        elif isinstance(result, dict):
-            result_str = str(result)
+        return {"status": "success", "result": run_ai_task(request.prompt)}
+    except Exception as exc:
+        logger.exception("Error while processing AI request.")
+        raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+
+@app.post("/api/auth")
+async def auth(request: AuthRequest):
+    try:
+        if has_database():
+            with get_db_connection() as conn:
+                with conn.cursor() as cur:
+                    if request.action == "signup":
+                        cur.execute(
+                            "INSERT INTO users (username, password) VALUES (%s, %s) RETURNING id",
+                            (request.username, request.password),
+                        )
+                        user_id = cur.fetchone()[0]
+                        conn.commit()
+                        return {"success": True, "message": "Signup successful!", "userId": user_id}
+
+                    cur.execute(
+                        "SELECT id FROM users WHERE username = %s AND password = %s",
+                        (request.username, request.password),
+                    )
+                    row = cur.fetchone()
+                    if row:
+                        return {"success": True, "message": "Login successful!", "userId": row[0]}
+                    return {"success": False, "message": "Invalid credentials."}
+
+        if request.action == "signup":
+            user_id = create_memory_user(request.username, request.password)
+            return {"success": True, "message": "Signup successful!", "userId": user_id}
+
+        user = memory_users.get(request.username)
+        if user and user["password"] == request.password:
+            return {"success": True, "message": "Login successful!", "userId": user["id"]}
+        return {"success": False, "message": "Invalid credentials."}
+    except Exception as exc:
+        logger.exception("Authentication error.")
+        return {"success": False, "message": f"DB Error: {exc}"}
+
+
+@app.post("/api/store-option")
+async def store_option(request: StoreOptionRequest):
+    try:
+        final_prompt = ""
+
+        if request.option == "Generate Code":
+            final_prompt = request.codePrompt or ""
+        elif request.option == "Modify Code":
+            final_prompt = request.modifyCode or ""
+
+        ai_output = run_ai_task(final_prompt)
+
+        if has_database():
+            with get_db_connection() as conn:
+                with conn.cursor() as cur:
+                    cur.execute(
+                        """
+                        INSERT INTO user_activity (
+                            user_id, user_option, language, qn,
+                            modify_code_input, modify_code_logic, output
+                        )
+                        VALUES (%s, %s, %s, %s, %s, %s, %s)
+                        """,
+                        (
+                            request.userId,
+                            request.option,
+                            request.language,
+                            final_prompt,
+                            request.modifyCode if request.option == "Modify Code" else None,
+                            request.modifyLogic if request.option == "Modify Code" else None,
+                            ai_output,
+                        ),
+                    )
+                conn.commit()
         else:
-            result_str = str(result)
-        
-        return {"status": "success", "result": result_str}
-    except Exception as e:
-        logging.exception("Error")
-        raise HTTPException(status_code=500, detail=str(e))
+            memory_activity.append(
+                {
+                    "user_id": request.userId,
+                    "user_option": request.option,
+                    "language": request.language,
+                    "qn": final_prompt,
+                    "modify_code_input": request.modifyCode if request.option == "Modify Code" else None,
+                    "modify_code_logic": request.modifyLogic if request.option == "Modify Code" else None,
+                    "output": ai_output,
+                }
+            )
+
+        return {
+            "success": True,
+            "message": f"{request.option} data stored successfully!",
+            "aiOutput": ai_output,
+        }
+    except Exception:
+        logger.exception("Error in store-option.")
+        return {"success": False, "message": "Error processing request."}
+
+
+@app.post("/api/analyze-code")
+async def analyze_code(request: AnalyzeCodeRequest):
+    analysis_prompt = f"""You are a code efficiency analyzer. Compare the ORIGINAL and MODIFIED code below and provide a detailed efficiency analysis.
+
+ORIGINAL CODE:
+{request.originalCode}
+
+MODIFIED CODE:
+{request.modifiedCode}
+
+IMPORTANT: You MUST include numerical scores in your analysis. Use the exact format "Label: X/10" for each metric. Include ALL of the following scored sections:
+
+TIME COMPLEXITY:
+- Time Original: [score]/10 — [analysis]
+- Time Modified: [score]/10 — [analysis]
+- Best/Average/Worst case analysis
+
+SPACE COMPLEXITY:
+- Space Original: [score]/10 — [analysis]
+- Space Modified: [score]/10 — [analysis]
+
+EXECUTION SPEED:
+- Speed Original: [score]/10 — [assessment]
+- Speed Modified: [score]/10 — [assessment]
+- Bottlenecks identified
+
+CODE READABILITY:
+- Readability Original: [score]/10 — [assessment]
+- Readability Modified: [score]/10 — [assessment]
+
+MAINTAINABILITY:
+- Maintainability Original: [score]/10 — [assessment]
+- Maintainability Modified: [score]/10 — [assessment]
+
+BEST PRACTICES:
+- Practices Original: [score]/10 — [compliance]
+- Practices Modified: [score]/10 — [compliance]
+
+SUMMARY: [Overall comparative summary]
+
+OVERALL EFFICIENCY SCORE: [score]/10 — [brief justification]
+
+Higher scores = better efficiency. Be precise with your /10 ratings."""
+
+    try:
+        result = run_ai_task(analysis_prompt)
+        return {"success": True, "message": "Analysis complete!", "analysisResult": result}
+    except Exception:
+        logger.exception("Error analyzing code.")
+        return {"success": False, "message": "Error analyzing code. Please try again later."}
+
+
+if FRONTEND_BUILD_DIR.exists():
+    app.mount("/assets", StaticFiles(directory=FRONTEND_BUILD_DIR / "static"), name="static")
+
+
+@app.get("/{full_path:path}")
+async def serve_frontend(full_path: str):
+    if not FRONTEND_BUILD_DIR.exists():
+        raise HTTPException(
+            status_code=404,
+            detail="Frontend build not found. Run the React build or deploy with the Dockerfile.",
+        )
+
+    candidate = FRONTEND_BUILD_DIR / full_path
+    if full_path and candidate.exists() and candidate.is_file():
+        return FileResponse(candidate)
+    return FileResponse(FRONTEND_BUILD_DIR / "index.html")
+
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+    uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("PORT", "7860")))