Add README and fix Windows compatibility

- Add project README with setup, CLI reference, and architecture overview
- Fix launch.py: Windows venv path, netstat/taskkill for port cleanup,
  npm.cmd resolution, guard SIGTERM behind hasattr
- Replace asyncio.get_event_loop().time() with time.monotonic() in
  ensembl, ncbi, and uniprot rate-limiting (cross-platform, not deprecated)
- Use asyncio.get_running_loop() in CellForge simulation route

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: SimplyLiz

README.md

@@ -0,0 +1,153 @@
+# BioLab
+
+Unified bioinformatics platform for gene analysis, evidence synthesis, and whole-cell simulation.
+
+BioLab combines genomic data ingestion, LLM-powered functional prediction, and multi-scale cell simulation into a single interactive environment. Load a genome, analyze genes against public databases, synthesize function hypotheses with AI, and simulate cellular behavior — all from one interface.
+
+## Features
+
+- **Multi-genome management** — load genomes from GenBank, NCBI accessions, Ensembl, or FASTA files
+- **Gene analysis & evidence synthesis** — aggregate functional evidence from BRENDA, SABIO-RK, KEGG, and Datanator
+- **LLM-powered predictions** — synthesize gene function hypotheses using Claude, OpenAI, or local Ollama models
+- **Cell simulation** — multi-timescale ODE engine covering metabolism, gene expression, growth, mutation, and epigenetics
+- **CellForge** — advanced whole-cell simulation with thermodynamic constraints, stochastic processes (Gillespie SSA), and FBA
+- **Population dynamics** — population-level growth, division, and genetic drift simulation
+- **Interactive frontend** — React/TypeScript UI with genome browser, petri dish visualization, knockout lab, and real-time charts
+- **CLI & API** — full Typer CLI and FastAPI REST/WebSocket API
+
+## Requirements
+
+- Python 3.11+
+- Node.js 18+ (for frontend)
+- Rust toolchain (optional, for native CellForge engine)
+
+## Quick Start
+
+```bash
+# Clone
+git clone https://github.com/SimplyLiz/BioLab.git
+cd BioLab
+
+# Python setup
+python -m venv .venv
+source .venv/bin/activate        # Linux/macOS
+# .venv\Scripts\activate         # Windows
+pip install -e ".[dev,llm]"
+
+# Frontend setup
+cd frontend && npm install && cd ..
+
+# Initialize database
+biolab init
+
+# Launch both backend and frontend
+python launch.py
+```
+
+Backend runs on `http://localhost:8000`, frontend on `http://localhost:5173`.
+
+## Configuration
+
+Set via environment variables or a `.env` file:
+
+| Variable | Description | Default |
+|---|---|---|
+| `ANTHROPIC_API_KEY` | Claude API key for LLM synthesis | — |
+| `OPENAI_API_KEY` | OpenAI API key (alternative provider) | — |
+| `LLM_PROVIDER` | `anthropic`, `openai`, or `ollama` | `anthropic` |
+| `LLM_MODEL` | Model name | `claude-sonnet-4-5-20250929` |
+| `DATABASE_URL` | SQLAlchemy database URL | `sqlite:///biolab.db` |
+| `NCBI_API_KEY` | NCBI E-utilities key (10 req/s vs 3) | — |
+| `NCBI_EMAIL` | Required by NCBI for identification | — |
+| `BIOLAB_BACKEND_PORT` | Backend port | `8000` |
+| `BIOLAB_FRONTEND_PORT` | Frontend port | `5173` |
+
+## CLI
+
+```
+biolab genes       Gene operations (list, import, search)
+biolab analyze     Deep gene analysis & LLM synthesis
+biolab evidence    Evidence source management
+biolab synthesize  LLM function synthesis
+biolab pipeline    Multi-phase evidence pipeline
+biolab validate    Validation and quality checks
+biolab cellforge   CellForge whole-cell simulation engine
+biolab init        Initialize database
+```
+
+### CellForge subcommands
+
+```
+biolab cellforge annotate <fasta>   Run genome annotation pipeline
+biolab cellforge run <config.json>  Run a whole-cell simulation
+biolab cellforge serve              Start the CellForge API server
+biolab cellforge benchmark          Run performance benchmarks
+biolab cellforge info               Show version and dependency info
+```
+
+## Docker
+
+```bash
+docker-compose up
+```
+
+This starts the backend (port 8000) and Redis cache (port 6379).
+
+For GPU-accelerated workloads:
+
+```bash
+docker build -f docker/Dockerfile.gpu -t biolab-gpu .
+```
+
+## Project Structure
+
+```
+src/biolab/
+  api/              REST API (FastAPI)
+  cli/              CLI commands (Typer)
+  services/         Business logic (LLM, ETL, import)
+  ingestion/        GenBank/FASTA parsing
+  simulation/       Core simulation engine
+  cellforge/        Advanced whole-cell simulation
+    core/           Simulation kernel
+    processes/      Biological processes (transcription, translation, etc.)
+    constraints/    Thermodynamic & energy constraints
+    annotation/     Genome annotation pipeline
+    api/            CellForge REST API
+  contrib/          Plugin modules (DNASyn evidence pipeline)
+  db/               Database models & migrations
+
+frontend/
+  src/pages/        React page components
+  src/components/   UI components (genome browser, petri dish, charts)
+  src/hooks/        Data fetching & state hooks
+  src/stores/       Zustand state management
+
+crates/
+  cellforge-engine/ Rust native simulation engine (optional)
+```
+
+## Optional Dependencies
+
+Install extras for additional capabilities:
+
+```bash
+pip install -e ".[cellforge]"    # CellForge (COBRApy, GillesPy2, Redis, Zarr)
+pip install -e ".[ml]"           # ML models (PyTorch, Transformers)
+pip install -e ".[validation]"   # Validation (libRoadRunner, matplotlib)
+pip install -e ".[dashboard]"    # Streamlit dashboard
+pip install -e ".[postgres]"     # PostgreSQL support
+```
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest                    # Run tests
+ruff check src/           # Lint
+mypy src/                 # Type check
+```
+
+## License
+
+All rights reserved.

launch.py

@@ -2,14 +2,23 @@
 """Launch BioLab backend + frontend in one shot. Ctrl-C kills both."""
 
 import os
+import platform
+import shutil
 import signal
 import subprocess
 import sys
 import time
 
 ROOT = os.path.dirname(os.path.abspath(__file__))
 FRONTEND_DIR = os.path.join(ROOT, "frontend")
-VENV_PYTHON = os.path.join(ROOT, ".venv", "bin", "python")
+
+IS_WINDOWS = platform.system() == "Windows"
+
+# Resolve venv python — Scripts/python.exe on Windows, bin/python elsewhere
+if IS_WINDOWS:
+    VENV_PYTHON = os.path.join(ROOT, ".venv", "Scripts", "python.exe")
+else:
+    VENV_PYTHON = os.path.join(ROOT, ".venv", "bin", "python")
 
 BACKEND_PORT = int(os.environ.get("BIOLAB_BACKEND_PORT", "8000"))
 FRONTEND_PORT = int(os.environ.get("BIOLAB_FRONTEND_PORT", "5173"))
@@ -20,11 +29,24 @@
 def kill_port(port: int) -> None:
     """Kill any process currently holding a port."""
     try:
-        out = subprocess.check_output(["lsof", "-ti", f":{port}"], text=True).strip()
-        for pid in out.splitlines():
-            os.kill(int(pid), signal.SIGKILL)
-        time.sleep(0.5)
-    except (subprocess.CalledProcessError, ValueError):
+        if IS_WINDOWS:
+            out = subprocess.check_output(
+                ["netstat", "-ano"], text=True, stderr=subprocess.DEVNULL,
+            )
+            for line in out.splitlines():
+                if f":{port}" in line and "LISTENING" in line:
+                    pid = line.strip().split()[-1]
+                    subprocess.run(
+                        ["taskkill", "/F", "/PID", pid],
+                        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                    )
+            time.sleep(0.5)
+        else:
+            out = subprocess.check_output(["lsof", "-ti", f":{port}"], text=True).strip()
+            for pid in out.splitlines():
+                os.kill(int(pid), signal.SIGKILL)
+            time.sleep(0.5)
+    except (subprocess.CalledProcessError, ValueError, OSError):
         pass
 
 
@@ -46,14 +68,14 @@ def shutdown(*_: object) -> None:
 
 def main() -> None:
     signal.signal(signal.SIGINT, shutdown)
-    signal.signal(signal.SIGTERM, shutdown)
+    if hasattr(signal, "SIGTERM"):
+        signal.signal(signal.SIGTERM, shutdown)
 
     # Free ports
     kill_port(BACKEND_PORT)
     kill_port(FRONTEND_PORT)
 
     # Backend — uvicorn with app factory
-    # Use venv python if available, otherwise fall back to current interpreter
     python = VENV_PYTHON if os.path.exists(VENV_PYTHON) else sys.executable
     print(f"\033[36m[BioLab]\033[0m Starting backend on :{BACKEND_PORT}")
     backend = subprocess.Popen(
@@ -66,10 +88,11 @@ def main() -> None:
     )
     procs.append(backend)
 
-    # Frontend
+    # Frontend — resolve npm executable (npm.cmd on Windows)
+    npm = shutil.which("npm") or ("npm.cmd" if IS_WINDOWS else "npm")
     print(f"\033[32m[BioLab]\033[0m Starting frontend on :{FRONTEND_PORT}")
     frontend = subprocess.Popen(
-        ["npm", "run", "dev", "--", "--port", str(FRONTEND_PORT)],
+        [npm, "run", "dev", "--", "--port", str(FRONTEND_PORT)],
         cwd=FRONTEND_DIR,
     )
     procs.append(frontend)

src/biolab/cellforge/api/routes/simulation.py

@@ -86,7 +86,7 @@ async def start_simulation(simulation_id: str) -> dict[str, str]:
 
     async def _run_sim() -> None:
         try:
-            loop = asyncio.get_event_loop()
+            loop = asyncio.get_running_loop()
             await loop.run_in_executor(None, sim.run)
             entry["status"] = "completed"
         except Exception:

src/biolab/services/ensembl.py

@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 import asyncio
+import time
 from typing import Any
 
 import httpx
@@ -21,11 +22,11 @@
 
 async def _throttle():
     global _last_request
-    now = asyncio.get_event_loop().time()
+    now = time.monotonic()
     wait = _THROTTLE - (now - _last_request)
     if wait > 0:
         await asyncio.sleep(wait)
-    _last_request = asyncio.get_event_loop().time()
+    _last_request = time.monotonic()
 
 
 # ---------------------------------------------------------------------------

src/biolab/services/ncbi.py

@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 import asyncio
+import time
 import xml.etree.ElementTree as ET
 from typing import Any
 
@@ -21,11 +22,11 @@
 
 async def _throttle():
     global _last_request
-    now = asyncio.get_event_loop().time()
+    now = time.monotonic()
     wait = _THROTTLE - (now - _last_request)
     if wait > 0:
         await asyncio.sleep(wait)
-    _last_request = asyncio.get_event_loop().time()
+    _last_request = time.monotonic()
 
 
 def _params(**kwargs) -> dict:

src/biolab/services/uniprot.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 import asyncio
+import time
 from typing import Any
 
 import httpx
@@ -19,11 +20,11 @@
 
 async def _throttle():
     global _last_request
-    now = asyncio.get_event_loop().time()
+    now = time.monotonic()
     wait = _THROTTLE - (now - _last_request)
     if wait > 0:
         await asyncio.sleep(wait)
-    _last_request = asyncio.get_event_loop().time()
+    _last_request = time.monotonic()
 
 
 async def search_by_gene(