#!/usr/bin/env python3

"""

DeepCode - AI Research Engine Launcher

🧬 Next-Generation AI Research Automation Platform

⚡ Transform research papers into working code automatically

Cross-platform support: Windows, macOS, Linux

"""

import os

import sys

import subprocess

import signal

import platform

import socket

import time

from pathlib import Path

# Global process references for cleanup

_backend_process = None

_frontend_process = None

def get_platform():

"""Get current platform"""

system = platform.system().lower()

if system == "darwin":

return "macos"

elif system == "windows":

return "windows"

else:

return "linux"

def check_dependencies():

"""Check if necessary dependencies are installed for new UI"""

import importlib.util

import shutil

print("🔍 Checking dependencies...")

missing_deps = []

missing_system_deps = []

# Check FastAPI availability (for backend)

if importlib.util.find_spec("fastapi") is not None:

print("✅ FastAPI is installed")

else:

missing_deps.append("fastapi>=0.104.0")

# Check uvicorn availability (for backend server)

if importlib.util.find_spec("uvicorn") is not None:

print("✅ Uvicorn is installed")

else:

missing_deps.append("uvicorn>=0.24.0")

# Check PyYAML availability

if importlib.util.find_spec("yaml") is not None:

print("✅ PyYAML is installed")

else:

missing_deps.append("pyyaml>=6.0")

# Check pydantic-settings availability

if importlib.util.find_spec("pydantic_settings") is not None:

print("✅ Pydantic-settings is installed")

else:

missing_deps.append("pydantic-settings>=2.0.0")

# Check Node.js availability (for frontend)

node_cmd = "node.exe" if get_platform() == "windows" else "node"

if shutil.which(node_cmd) or shutil.which("node"):

try:

result = subprocess.run(

["node", "--version"],

capture_output=True,

text=True,

timeout=5,

shell=(get_platform() == "windows"),

)

if result.returncode == 0:

print(f"✅ Node.js is installed ({result.stdout.strip()})")

except Exception:

missing_system_deps.append("Node.js")

else:

missing_system_deps.append("Node.js")

print("❌ Node.js not found (required for frontend)")

# Check npm availability

npm_cmd = "npm.cmd" if get_platform() == "windows" else "npm"

if shutil.which(npm_cmd) or shutil.which("npm"):

print("✅ npm is available")

else:

missing_system_deps.append("npm")

print("❌ npm not found (required for frontend)")

# Display missing dependencies

if missing_deps or missing_system_deps:

print("\n📋 Dependency Status:")

if missing_deps:

print("❌ Missing Python dependencies:")

for dep in missing_deps:

print(f" - {dep}")

print(f"\nInstall with: pip install {' '.join(missing_deps)}")

if missing_system_deps:

print("\n❌ Missing system dependencies:")

for dep in missing_system_deps:

print(f" - {dep}")

print("\nInstall Node.js:")

print(" - Windows/macOS: https://nodejs.org/")

print(" - macOS: brew install node")

print(" - Ubuntu/Debian: sudo apt-get install nodejs npm")

# Fail if critical dependencies are missing

if missing_deps or missing_system_deps:

return False

else:

print("✅ All dependencies satisfied")

return True

def is_port_in_use(port: int) -> bool:

"""Check if a port is in use (cross-platform)"""

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:

return s.connect_ex(("localhost", port)) == 0

def kill_process_on_port(port: int):

"""Kill process using a specific port (cross-platform)"""

current_platform = get_platform()

try:

if current_platform == "windows":

# Windows: use netstat and taskkill

result = subprocess.run(

f"netstat -ano | findstr :{port}",

capture_output=True,

text=True,

shell=True,

)

if result.stdout:

for line in result.stdout.strip().split("\n"):

parts = line.split()

if len(parts) >= 5:

pid = parts[-1]

if pid.isdigit():

subprocess.run(

f"taskkill /F /PID {pid}",

shell=True,

capture_output=True,

)

print(f" ✓ Killed process on port {port} (PID: {pid})")

else:

# macOS/Linux: use lsof

result = subprocess.run(

f"lsof -ti :{port}", capture_output=True, text=True, shell=True

)

if result.stdout:

pids = result.stdout.strip().split("\n")

for pid in pids:

if pid.isdigit():

os.kill(int(pid), signal.SIGKILL)

print(f" ✓ Killed process on port {port} (PID: {pid})")

except Exception as e:

print(f" ⚠️ Could not kill process on port {port}: {e}")

def cleanup_ports():

"""Clean up ports 8000 and 5173 if in use"""

for port in [8000, 5173]:

if is_port_in_use(port):

print(f"⚠️ Port {port} is in use, cleaning up...")

kill_process_on_port(port)

time.sleep(1)

def install_backend_deps():

"""Install backend dependencies if needed"""

import importlib.util

if importlib.util.find_spec("fastapi") is None:

print("📦 Installing backend dependencies...")

deps = [

"fastapi",

"uvicorn",

"pydantic-settings",

"python-multipart",

"aiofiles",

"websockets",

"pyyaml",

]

subprocess.run(

[sys.executable, "-m", "pip", "install", "-q"] + deps, check=True

)

print("✅ Backend dependencies installed")

def install_frontend_deps(frontend_dir: Path):

"""Install frontend dependencies if needed"""

node_modules = frontend_dir / "node_modules"

if not node_modules.exists():

print("📦 Installing frontend dependencies (first run)...")

npm_cmd = "npm.cmd" if get_platform() == "windows" else "npm"

subprocess.run(

[npm_cmd, "install"],

cwd=frontend_dir,

check=True,

shell=(get_platform() == "windows"),

)

print("✅ Frontend dependencies installed")

def start_backend(backend_dir: Path):

"""Start the backend server"""

global _backend_process

print("🔧 Starting backend server...")

# Use shell=True on Windows for proper command handling

if get_platform() == "windows":

_backend_process = subprocess.Popen(

f'"{sys.executable}" -m uvicorn main:app --host 0.0.0.0 --port 8000 --reload',

cwd=backend_dir,

shell=True,

creationflags=subprocess.CREATE_NEW_PROCESS_GROUP,

)

else:

_backend_process = subprocess.Popen(

[

sys.executable,

"-m",

"uvicorn",

"main:app",

"--host",

"0.0.0.0",

"--port",

"8000",

"--reload",

],

cwd=backend_dir,

start_new_session=True, # Create new process group

)

# Wait for backend to start

time.sleep(2)

if _backend_process.poll() is None:

print("✅ Backend started: http://localhost:8000")

return True

else:

print("❌ Backend failed to start")

return False

def start_frontend(frontend_dir: Path):

"""Start the frontend dev server"""

global _frontend_process

print("🎨 Starting frontend server...")

npm_cmd = "npm.cmd" if get_platform() == "windows" else "npm"

if get_platform() == "windows":

_frontend_process = subprocess.Popen(

f"{npm_cmd} run dev",

cwd=frontend_dir,

shell=True,

creationflags=subprocess.CREATE_NEW_PROCESS_GROUP,

)

else:

_frontend_process = subprocess.Popen(

[npm_cmd, "run", "dev"],

cwd=frontend_dir,

start_new_session=True, # Create new process group

)

# Wait for frontend to start

time.sleep(3)

if _frontend_process.poll() is None:

print("✅ Frontend started: http://localhost:5173")

return True

else:

print("❌ Frontend failed to start")

return False

def cleanup_processes():

"""Clean up running processes"""

global _backend_process, _frontend_process

print("\n🛑 Stopping services...")

for name, proc in [("Backend", _backend_process), ("Frontend", _frontend_process)]:

if proc and proc.poll() is None:

try:

if get_platform() == "windows":

# Windows: use taskkill with /T to kill tree

subprocess.run(

f"taskkill /F /T /PID {proc.pid}",

shell=True,

capture_output=True,

)

else:

# Unix: kill the process group

try:

os.killpg(os.getpgid(proc.pid), signal.SIGTERM)

proc.wait(timeout=5)

except Exception:

os.killpg(os.getpgid(proc.pid), signal.SIGKILL)

print(f" ✓ {name} stopped")

except Exception:

# Fallback: try direct terminate

try:

proc.terminate()

proc.wait(timeout=3)

print(f" ✓ {name} stopped")

except Exception:

try:

proc.kill()

print(f" ✓ {name} killed")

except Exception:

print(f" ⚠️ Could not stop {name}")

# Also clean up any orphaned processes on ports

time.sleep(0.5)

for port in [8000, 5173]:

if is_port_in_use(port):

kill_process_on_port(port)

print("✅ All services stopped")

def cleanup_cache():

"""Clean up Python cache files"""

try:

print("🧹 Cleaning up cache files...")

# Clean up __pycache__ directories

os.system('find . -type d -name "__pycache__" -exec rm -r {} + 2>/dev/null')

# Clean up .pyc files

os.system('find . -name "*.pyc" -delete 2>/dev/null')

print("✅ Cache cleanup completed")

except Exception as e:

print(f"⚠️ Cache cleanup failed: {e}")

def print_banner():

"""Display startup banner"""

banner = """

╔══════════════════════════════════════════════════════════════╗

║ ║

║ 🧬 DeepCode - AI Research Engine ║

║ ║

║ ⚡ NEURAL • AUTONOMOUS • REVOLUTIONARY ⚡ ║

║ ║

║ Transform research papers into working code ║

║ Next-generation AI automation platform ║

║ ║

╚══════════════════════════════════════════════════════════════╝

"""

print(banner)

def launch_classic_ui():

"""Launch classic Streamlit UI"""

import importlib.util

print("🌐 Launching Classic Streamlit UI...")

# Check if Streamlit is installed

if importlib.util.find_spec("streamlit") is None:

print("❌ Streamlit is not installed.")

print("Install with: pip install streamlit")

sys.exit(1)

current_dir = Path(__file__).parent

streamlit_app_path = current_dir / "ui" / "streamlit_app.py"

if not streamlit_app_path.exists():

print(f"❌ Streamlit app not found: {streamlit_app_path}")

sys.exit(1)

print(f"📁 UI App: {streamlit_app_path}")

print("🚀 Launching on http://localhost:8501")

print("=" * 70)

try:

cmd = [

sys.executable,

"-m",

"streamlit",

"run",

str(streamlit_app_path),

"--server.port",

"8501",

"--server.address",

"localhost",

"--browser.gatherUsageStats",

"false",

]

subprocess.run(cmd, check=True)

except KeyboardInterrupt:

print("\n\n🛑 Streamlit server stopped by user")

except Exception as e:

print(f"\n❌ Error: {e}")

sys.exit(1)

def _check_docker_prerequisites():

"""Check Docker prerequisites and config files. Returns (current_dir, compose_file, compose_args)."""

import shutil

current_dir = Path(__file__).parent

compose_file = current_dir / "deepcode_docker" / "docker-compose.yml"

if not compose_file.exists():

print("❌ deepcode_docker/docker-compose.yml not found")

print(" Make sure you are running from the DeepCode project root.")

sys.exit(1)

# Check Docker is installed

if not shutil.which("docker"):

print("❌ Docker not found. Please install Docker Desktop first.")

print(" https://www.docker.com/products/docker-desktop")

sys.exit(1)

# Check Docker daemon is running

result = subprocess.run(["docker", "info"], capture_output=True, text=True)

if result.returncode != 0:

print("❌ Docker is installed but not running.")

print(" Please start Docker Desktop and try again.")

sys.exit(1)

# Check/create secrets file

secrets_file = current_dir / "mcp_agent.secrets.yaml"

if not secrets_file.exists():

example = current_dir / "mcp_agent.secrets.yaml.example"

if example.exists():

print("⚠️ mcp_agent.secrets.yaml not found.")

print(" Creating from template...")

import shutil as sh

sh.copy2(example, secrets_file)

print(f" ✅ Created {secrets_file}")

print("")

print(" ⚠️ Please edit mcp_agent.secrets.yaml and fill in your API keys:")

print(f" {secrets_file}")

print("")

print(

" At least ONE LLM provider key is required (OpenAI/Anthropic/Google)."

)

print(" Then run 'deepcode' again.")

sys.exit(0)

else:

print(

"❌ mcp_agent.secrets.yaml not found. Please create it with your API keys."

)

sys.exit(1)

# Check config file

config_file = current_dir / "mcp_agent.config.yaml"

if not config_file.exists():

print("❌ mcp_agent.config.yaml not found.")

print(" This file should be in the project root.")

sys.exit(1)

# Ensure data directories exist

for d in ["deepcode_lab", "uploads", "logs"]:

(current_dir / d).mkdir(exist_ok=True)

os.chdir(current_dir)

compose_args = ["docker", "compose", "-f", str(compose_file)]

return current_dir, compose_file, compose_args

def launch_docker():

"""Launch DeepCode via Docker"""

current_dir, compose_file, compose_args = _check_docker_prerequisites()

print("🐳 Starting DeepCode with Docker...")

print("=" * 50)

try:

# Check if image exists (auto-build on first run)

result = subprocess.run(

compose_args + ["images", "-q"], capture_output=True, text=True

)

if not result.stdout.strip():

print(

"📦 First run detected — building Docker image (may take a few minutes)..."

)

subprocess.run(compose_args + ["build"], check=True)

# Start (if already running, docker compose will detect and skip)

subprocess.run(compose_args + ["up", "-d"], check=True)

print("")

print("=" * 50)

print("✅ DeepCode is running!")

print("")

print(" 🌐 Open: http://localhost:8000")

print(" 📚 Docs: http://localhost:8000/docs")

print("")

print(" 📋 View logs: docker logs deepcode -f")

print(

" 🛑 Stop: docker compose -f deepcode_docker/docker-compose.yml down"

)

print("=" * 50)

except subprocess.CalledProcessError as e:

print(f"\n❌ Docker failed: {e}")

sys.exit(1)

except KeyboardInterrupt:

print("\n🛑 Cancelled")

def launch_docker_cli():

"""Launch DeepCode CLI inside Docker container"""

current_dir, compose_file, compose_args = _check_docker_prerequisites()

print("🖥️ Starting DeepCode CLI in Docker...")

print("=" * 50)

try:

# Check if image exists (auto-build on first run)

result = subprocess.run(

compose_args + ["images", "-q"], capture_output=True, text=True

)

if not result.stdout.strip():

print(

"📦 First run detected — building Docker image (may take a few minutes)..."

)

subprocess.run(compose_args + ["build"], check=True)

# Run CLI interactively

subprocess.run(

compose_args + ["run", "--rm", "-it", "deepcode", "cli"], check=True

)

except subprocess.CalledProcessError as e:

print(f"\n❌ Docker failed: {e}")

sys.exit(1)

except KeyboardInterrupt:

print("\n🛑 Cancelled")

def launch_paper_test(paper_name: str, fast_mode: bool = False):

"""Launch paper testing mode"""

try:

print("\n🧪 Launching Paper Test Mode")

print(f"📄 Paper: {paper_name}")

print(f"⚡ Fast mode: {'enabled' if fast_mode else 'disabled'}")

print("=" * 60)

# Run the test setup

setup_cmd = [sys.executable, "test_paper.py", paper_name]

if fast_mode:

setup_cmd.append("--fast")

result = subprocess.run(setup_cmd, check=True)

if result.returncode == 0:

print("\n✅ Paper test setup completed successfully!")

print("📁 Files are ready in deepcode_lab/papers/")

print("\n💡 Next steps:")

print(" 1. Install MCP dependencies: pip install -r requirements.txt")

print(

f" 2. Run full pipeline: python -m workflows.paper_test_engine --paper {paper_name}"

+ (" --fast" if fast_mode else "")

)

except subprocess.CalledProcessError as e:

print(f"\n❌ Paper test setup failed: {e}")

sys.exit(1)

except Exception as e:

print(f"\n❌ Unexpected error: {e}")

sys.exit(1)

def main():

"""Main function"""

# Parse command line arguments

if len(sys.argv) > 1:

if sys.argv[1] == "test" and len(sys.argv) >= 3:

# Paper testing mode: python deepcode.py test rice [--fast]

paper_name = sys.argv[2]

fast_mode = "--fast" in sys.argv or "-f" in sys.argv

print_banner()

launch_paper_test(paper_name, fast_mode)

return

elif sys.argv[1] == "--local":

# Launch locally (without Docker) — fall through to local launch below

print_banner()

pass

elif sys.argv[1] == "--docker":

# Explicit Docker launch (same as default)

print_banner()

launch_docker()

return

elif sys.argv[1] == "--cli":

# Launch CLI inside Docker container

print_banner()

launch_docker_cli()

return

elif sys.argv[1] == "--classic":

# Launch classic Streamlit UI

print_banner()

launch_classic_ui()

return

elif sys.argv[1] in ["--help", "-h", "help"]:

print_banner()

print("""

🔧 Usage:

deepcode - Launch via Docker (default, recommended)

deepcode --docker - Same as above (launch via Docker)

deepcode --cli - Launch interactive CLI in Docker

deepcode --local - Launch locally (requires Python + Node.js)

deepcode test <paper> - Test paper reproduction

deepcode test <paper> --fast - Test paper (fast mode)

deepcode --classic - Launch classic Streamlit UI

📄 Examples:

deepcode - Start with Docker (one command)

deepcode --cli - Interactive CLI in Docker

deepcode --local - Start the new UI locally

deepcode test rice - Test RICE paper reproduction

deepcode test rice --fast - Test RICE paper (fast mode)

🌐 New UI Features:

• User-in-Loop interaction

• Real-time progress tracking

• Inline chat interaction

• Modern React-based interface

📁 Available papers:""")

# List available papers

papers_dir = "papers"

if os.path.exists(papers_dir):

for item in os.listdir(papers_dir):

item_path = os.path.join(papers_dir, item)

if os.path.isdir(item_path):

paper_md = os.path.join(item_path, "paper.md")

addendum_md = os.path.join(item_path, "addendum.md")

status = "✅" if os.path.exists(paper_md) else "❌"

addendum_status = "📄" if os.path.exists(addendum_md) else "➖"

print(f" {status} {item} {addendum_status}")

print(

"\n Legend: ✅ = paper.md exists, 📄 = addendum.md exists, ➖ = no addendum"

)

return

else:

# Unknown argument — show help hint

print(f"Unknown option: {sys.argv[1]}")

print("Run 'deepcode --help' for usage information.")

sys.exit(1)

else:

# Default (no arguments) → Docker

print_banner()

launch_docker()

return

# --- Local launch (only reached via --local) ---

# Show platform info

current_platform = get_platform()

print(f"🖥️ Platform: {current_platform.capitalize()}")

# Check dependencies

if not check_dependencies():

print("\n🚨 Please install missing dependencies and try again.")

sys.exit(1)

# Get paths

current_dir = Path(__file__).parent

new_ui_dir = current_dir / "new_ui"

backend_dir = new_ui_dir / "backend"

frontend_dir = new_ui_dir / "frontend"

# Check if new_ui directory exists

if not new_ui_dir.exists():

print(f"❌ New UI directory not found: {new_ui_dir}")

sys.exit(1)

print("\n🚀 Starting DeepCode New UI...")

print("=" * 70)

print("🎨 Frontend: http://localhost:5173")

print("🔧 Backend: http://localhost:8000")

print("📚 API Docs: http://localhost:8000/docs")

print("=" * 70)

print("💡 Tip: Keep this terminal open while using the application")

print("🛑 Press Ctrl+C to stop all services")

print("=" * 70)

try:

# Clean up ports if in use

cleanup_ports()

# Install dependencies if needed

install_backend_deps()

install_frontend_deps(frontend_dir)

# Start services

if not start_backend(backend_dir):

print("❌ Failed to start backend")

sys.exit(1)

if not start_frontend(frontend_dir):

print("❌ Failed to start frontend")

cleanup_processes()

sys.exit(1)

print("\n" + "=" * 70)

print("╔════════════════════════════════════════╗")

print("║ 🎉 DeepCode New UI is running! ║")

print("╠════════════════════════════════════════╣")

print("║ ║")

print("║ 🌐 Frontend: http://localhost:5173 ║")

print("║ 🔧 Backend: http://localhost:8000 ║")

print("║ 📚 API Docs: http://localhost:8000/docs║")

print("║ ║")

print("║ Press Ctrl+C to stop all services ║")

print("╚════════════════════════════════════════╝")

print("=" * 70 + "\n")

# Wait for processes

while True:

# Check if processes are still running

if _backend_process and _backend_process.poll() is not None:

print("⚠️ Backend process exited unexpectedly")

break

if _frontend_process and _frontend_process.poll() is not None:

print("⚠️ Frontend process exited unexpectedly")

break

time.sleep(1)

except KeyboardInterrupt:

print("\n")

except Exception as e:

print(f"\n❌ Unexpected error: {e}")

finally:

cleanup_processes()

cleanup_cache()

print("Thank you for using DeepCode! 🧬")

if __name__ == "__main__":

main()