Complete EcoNav app flow with routing, AI prediction, and training

.gitignore

@@ -1,3 +1,49 @@
+<<<<<<< HEAD
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# Dependencies
+node_modules
+.pnp
+.pnp.js
+
+# Local env files
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Testing
+coverage
+
+# Turbo
+.turbo
+
+# Vercel
+.vercel
+
+# Build Outputs
+.next/
+out/
+build
+dist
+
+
+# Debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Misc
+.DS_Store
+*.pem
+.venv
+.venv/
+__pycache__/
+*.pyc
+*.pkl
+models/eco_model.pth
+=======
 .venv/
 __pycache__/
 *.pyc
@@ -6,3 +52,4 @@ __pycache__/
 node_modules/
 .env
 dist/
+>>>>>>> 1c2f25b401a67215ea459ece945cb72cc7dbd373

Dockerfile

@@ -1,46 +1,49 @@
-# Use a specific slim Python image that matches openenv.yaml
+# Stage 1: Build the frontend
+FROM node:20-slim AS frontend-build
+WORKDIR /app
+COPY package*.json ./
+COPY apps/frontend/package*.json ./apps/frontend/
+RUN rm -rf package-lock.json
+RUN npm install
+COPY . .
+WORKDIR /app/apps/frontend
+RUN npx vite build
+
+# Stage 2: Final image
 FROM python:3.10-slim
 
 # Set environment variables
 ENV PYTHONUNBUFFERED=1 \
     PYTHONDONTWRITEBYTECODE=1 \
     PORT=7860
 
-# Set working directory
 WORKDIR /app
 
 # Install system dependencies
-# Install system dependencies with better error handling and common tools
 RUN apt-get update && apt-get install -y --no-install-recommends \
     build-essential \
     curl \
-    git \
     && rm -rf /var/lib/apt/lists/*
 
-# Install uv for fast dependency resolution
+# Install uv and requirements
 RUN pip install --no-cache-dir uv
-
-# Copy ONLY requirements first to leverage Docker cache
 COPY requirements/ ./requirements/
 COPY pyproject.toml uv.lock ./
-
-# Install project dependencies with uv
 RUN uv pip install --system --no-cache -r requirements/backend.txt -r requirements/ml.txt
 
-# Copy the rest of the application
+# Copy everything
 COPY . .
 
-# Set up a new user named "user" with UID 1000 for HF Spaces compatibility
+# Copy the bundled frontend from Stage 1
+COPY --from=frontend-build /app/apps/frontend/dist /app/apps/frontend/dist
+
+# Set up user for HF
 RUN useradd -m -u 1000 user && \
     chown -R user:user /app
 USER user
 ENV PATH="/home/user/.local/bin:$PATH"
 
-# Expose the standard Hugging Face Space port
 EXPOSE 7860
 
-# No HEALTHCHECK needed for standard HF Spaces and validator deployments,
-# simplifies build logic and reduces potential for false failures.
-
-# Start the application using uvicorn correctly
+# Run the backend (which now serves the dist folder)
 CMD ["uvicorn", "apps.backend.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -5,96 +5,132 @@ colorFrom: green
 colorTo: blue
 sdk: docker
 app_port: 7860
-pinned: false
+pinned: true
 ---
 
-# 🌱 EcoNav AI — Exposure Credit OpenEnv
+# 🌱 EcoNav AI — Exposure Credit Platform
 
-An OpenEnv-compliant Reinforcement Learning environment built for the Meta AI Environmental Decision Intelligence Hackathon. 
+[![EcoNav CI/CD](https://github.com/omdharb-bit/EcoNav-AI/actions/workflows/main.yml/badge.svg)](https://github.com/omdharb-bit/EcoNav-AI/actions)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![OpenEnv Compliant](https://img.shields.io/badge/OpenEnv-Compliant-10b981)](https://github.com/OpenEnv/spec)
 
-## 🌍 Environment Description & Motivation
+EcoNav AI is an **intelligent routing platform** and Reinforcement Learning (RL) environment built for the **Meta AI Environmental Decision Intelligence Hackathon**. It empowers users and agents to navigate urban networks while minimizing pollution exposure and maximizing health "Exposure Credits."
 
-EcoNav AI models a realistic urban navigation challenge where an intelligent agent must route through an Indian city network (represented as a dynamic graph). Instead of optimizing solely for distance or time, the agent optimizes to **minimize pollution exposure** and maximize **Exposure Credits**—a gamified health currency.
+---
 
-What makes this environment highly functional and unique is its integration with **live, real-world data**. The environment fetches real-time Air Quality Index (AQI) values from the Open-Meteo API. As the agent navigates segments, edge weights (pollution levels) dynamically shift based on reality. The agent earns credits for traversing clean-air segments (Grade A) and loses credits for heavily polluted segments (Grade F). This fills a real gap in mobility algorithms: exposure-aware routing evaluated as an RL task.
+## 🌍 Project Overview
 
-## 🧠 Action and Observation Spaces
+EcoNav AI transforms navigation from a simple distance-minimization problem into a **multi-objective environmental optimization task**. By integrating real-time Air Quality Index (AQI) data with dynamic traffic simulations, the platform provides a realistic testing ground for eco-aware agents.
 
-### Observation Space
-The observation space is a strictly typed JSON dictionary detailing the agent's current location, remaining budget, and available next moves including real-time sensor metrics:
-- `current_city` (str): Current city code (e.g. "A").
-- `current_city_name` (str): Human readable city name (e.g. "Delhi").
-- `destination` (str): Target destination code.
-- `destination_name` (str): Target human readable city name.
-- `visited` (list[str]): City codes already traversed.
-- `neighbors` (list[dict]): Available adjacent cities, featuring:
-  - `distance`: Distance to neighbor (km).
-  - `aqi`: Real-time Air Quality Index.
-  - `grade`: Computed health grade (A to F).
-  - `credit_delta`: Credits that will be won or lost by making this move.
-- `exposure_credits` (int): Current credit balance (starts at 100).
-- `total_exposure` (float): Cumulative normalized pollution exposure metric.
-- `steps_taken` (int): Number of steps used in current episode.
-- `max_steps` (int): Step budget limit for the current task.
+### Key Innovations:
+- **Live AQI Integration**: Real-time pollution data fetched from the Open-Meteo API for 50+ network nodes across India.
+- **Exposure Credits**: A gamified health currency that penalizes high-pollution segments (Grade F) and rewards clean-air segments (Grade A).
+- **Dynamic Traffic Engine**: Simulates congestion levels that impact both travel time and localized pollution exposure.
+- **OpenEnv Compliance**: Fully compatible with the OpenEnv specification for RL evaluation and agent deployment.
 
-### Action Space
-- `city` (str): A string specifying the city code to move to next. The chosen code must belong to the list of current `neighbors`.
+---
 
-## 📜 Tasks & Expected Difficulty
+## 🛠 Tech Stack
 
-Four discrete tasks of increasing difficulty force the agent to balance trade-offs between step budget, distance, and real-world pollution grids.
+The project is architected as a modern **monorepo** for seamless development and deployment.
 
-1. **`easy_route` (Easy)**: Navigate from highly-polluted Delhi to Kolkata. Generous step budget (15 steps) allowing maximum flexibility to seek clean air routes. Baseline passing score: 0.5.
-2. **`medium_route` (Medium)**: Same route, but optimized budget (8 steps). Requires balancing direct paths with pollution spikes. Baseline passing score: 0.6.
-3. **`hard_pollution_dodge` (Hard)**: Start from Agra to Kolkata with a tight budget (6 steps). Requires aggressive credit optimization to survive the early exposure hits of Northern India. Baseline passing score: 0.7.
-4. **`expert_credit_max` (Expert)**: Maximize exposure credits while reaching Kolkata within 10 steps. A rigorous test of the agent's multi-objective reward policy. Baseline passing score: 0.8.
+- **Backend**: Python 3.10+, FastAPI, Uvicorn, Pydantic, Torch (ML scoring).
+- **Frontend**: Vite, Vanilla JS, CSS3 (Glassmorphism), Leaflet.js (Mapping), Chart.js (Analytics).
+- **Infrastructure**: Docker, Turbo (Build system), GitHub Actions (CI/CD).
+- **Quality**: Ruff (Linting), Prettier (Formatting).
 
-## 🏆 Baseline Scores
+---
 
-We ran the included `inference.py` evaluating a greedy baseline heuristic (which strictly prefers neighbors with higher credit deltas and lower AQI values).
+## 📂 Repository Structure
+
+```text
+EcoNav-AI/
+├── apps/
+│   ├── backend/         # FastAPI server, AI services, and RL endpoints
+│   ├── frontend/        # Vite-powered dashboard and mapping interface
+│   ├── simulator/       # ML training and evaluation logic
+│   └── web/             # (Deprecated) Static web assets
+├── packages/
+│   └── env_core/        # Shared RL environment logic (OpenEnv Spec)
+├── requirements/        # Modularized dependency lists
+├── server/              # Production entry points for Docker/HF Spaces
+├── turbo.json           # Monorepo configuration
+└── inference.py         # Baseline agent evaluation script
+```
 
-| Task | Score (0.0 - 1.0) | Grade | Credits Final | Reached Goal |
-|---|---|---|---|---|
-| `easy_route` | 0.8161 | B | 110 | ✅ |
-| `medium_route` | 0.8161 | B | 110 | ✅ |
-| `hard_pollution_dodge` | 0.8326 | B | 105 | ✅ |
-| `expert_credit_max`| 0.8161 | B | 110 | ✅ |
-| **Average Score** | **0.8202** | | | |
+---
 
-## 🚀 Setup and Usage Instructions
+## 🚀 Getting Started
+
+### Prerequisites
+- **Node.js**: >= 18.0.0
+- **Python**: >= 3.10
+- **npm**: >= 11.11.0
+
+### Quick Start (Recommended)
+1. **Clone the repository**:
+   ```bash
+   git clone https://github.com/omdharb-bit/EcoNav-AI.git
+   cd EcoNav-AI
+   ```
+
+2. **Install Dependencies**:
+   ```bash
+   npm install      # Installs monorepo build tools
+   pip install -r requirements/backend.txt  # Installs Python backend deps
+   ```
+
+3. **Run Everything**:
+   Use the Turbo-powered development command to start both the backend and frontend:
+   ```bash
+   npm run dev
+   ```
+   *Note: If running on Windows, you may need to set `PYTHONPATH="."` manually if starting the backend via script.*
+
+### Manual Startup
+- **Backend**: `python server/app.py` (Runs on [http://localhost:7860](http://localhost:7860))
+- **Frontend**: `npm run dev --prefix apps/frontend` (Runs on [http://localhost:5173](http://localhost:5173))
 
-### Run via Docker (Hugging Face Spaces)
-The provided `Dockerfile` is optimized to run on Hugging Face Spaces per the OpenEnv specification (automatically exposing port `7860`).
-```bash
-docker build -t econav-openenv .
-docker run -p 7860:7860 econav-openenv
-```
-
-### Local Development Setup
-```bash
-python3 -m venv .venv
-source .venv/bin/activate
-pip install -r requirements.txt # OR pip install fastapi uvicorn requests pydantic openai numpy pyyaml
+---
 
-# Start the environment
-uvicorn apps.backend.main:app --host 0.0.0.0 --port 8000
-```
+## 🧠 RL Evaluation (OpenEnv)
 
-### Running Inference
-Run the baseline evaluation or LLM-driven agent via `inference.py`.
+The environment supports four standard evaluation tasks of increasing complexity:
+1. `easy_route`: Delhi to Kolkata (15 steps).
+2. `medium_route`: Delhi to Kolkata (8 steps).
+3. `hard_pollution_dodge`: Agra to Kolkata (6 steps).
+4. `expert_credit_max`: Maximize credits while reaching the goal (10 steps).
 
-**To run the greedy baseline:**
+**Baseline Evaluation**:
 ```bash
-export ENV_URL="http://127.0.0.1:8000"
+export ENV_URL="http://127.0.0.1:7860"
 python inference.py
 ```
 
-**To run the LLM Agent (OpenAI Client format):**
-```bash
-export ENV_URL="http://127.0.0.1:8000"
-export API_BASE_URL="https://router.huggingface.co/v1"
-export MODEL_NAME="meta-llama/Llama-3.1-8B-Instruct"
-export HF_TOKEN="your-hf-token"
+---
+
+## 🧪 Development & Quality
+
+We maintain high code quality standards through automated linting and formatting.
+
+- **Linting (Python)**: `ruff check .`
+- **Fix Linting**: `ruff check --fix .`
+- **Formatting (JS/TS/MD)**: `npm run format`
+
+---
+
+## 🏆 Project Status
+
+| Check | Status |
+|---|---|
+| **CI/CD Pipeline** | Passing ✅ |
+| **OpenEnv Spec** | Compliant (v1.0) 🟢 |
+| **Real-time Data** | Active (Open-Meteo) 🛰️ |
+| **Model Version** | EcoScorer v2.1 🧠 |
+
+---
+
+## 📜 License
+
+Distributed under the **MIT License**. See `LICENSE` for more information.
 
-python inference.py
-```