Makefile

# PE Packer Project Makefile
# Common commands for development, testing, and building

# Configuration
PROJECT_NAME := pe-packer
RUST_PACKAGE_NAME := pe_packer
PYTHON_PACKAGE_NAME := pe_packer
CARGO := cargo
UV := uv
MATURIN := maturin
PYTEST := pytest
PYTHON := python

# Colors for output
GREEN := \033[0;32m
YELLOW := \033[0;33m
RED := \033[0;31m
BLUE := \033[0;34m
NC := \033[0m # No Color

# Default target
.DEFAULT_GOAL := help

.PHONY: help
help:  ## Display this help message
	@echo "PE Packer Project - Available commands:"
	@echo ""
	@echo "$(GREEN)Development:$(NC)"
	@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {printf "  $(YELLOW)%-20s$(NC) %s\n", $$1, $$2}' $(MAKEFILE_LIST)
	@echo ""
	@echo "$(GREEN)Python:$(NC)"
	@awk 'BEGIN {FS = ":.*?## "} /^py-[a-zA-Z_-]+:.*?## / {printf "  $(YELLOW)%-20s$(NC) %s\n", $$1, $$2}' $(MAKEFILE_LIST)
	@echo ""
	@echo "$(GREEN)Rust:$(NC)"
	@awk 'BEGIN {FS = ":.*?## "} /^rust-[a-zA-Z_-]+:.*?## / {printf "  $(YELLOW)%-20s$(NC) %s\n", $$1, $$2}' $(MAKEFILE_LIST)
	@echo ""
	@echo "$(GREEN)Testing:$(NC)"
	@awk 'BEGIN {FS = ":.*?## "} /^test-[a-zA-Z_-]+:.*?## / {printf "  $(YELLOW)%-20s$(NC) %s\n", $$1, $$2}' $(MAKEFILE_LIST)
	@echo ""
	@echo "$(GREEN)Build & Release:$(NC)"
	@awk 'BEGIN {FS = ":.*?## "} /^(build|release|dist)-[a-zA-Z_-]+:.*?## / {printf "  $(YELLOW)%-20s$(NC) %s\n", $$1, $$2}' $(MAKEFILE_LIST)

# Development
.PHONY: setup
setup: venv rust-deps  ## Setup development environment

.PHONY: clean
clean: clean-rust clean-python  ## Clean all build artifacts

.PHONY: venv
venv:  ## Create Python virtual environment with uv
	@echo "$(BLUE)Creating virtual environment...$(NC)"
	$(UV) venv
	@echo "$(GREEN)Virtual environment created$(NC)"

.PHONY: install
install: venv  ## Install all dependencies
	@echo "$(BLUE)Installing dependencies...$(NC)"
	$(UV) sync --extra dev --extra training
	@echo "$(GREEN)Dependencies installed$(NC)"

.PHONY: update
update:  ## Update all dependencies
	@echo "$(BLUE)Updating dependencies...$(NC)"
	$(UV) pip compile --upgrade pyproject.toml
	$(UV) sync --extra dev --extra training
	@echo "$(GREEN)Dependencies updated$(NC)"

# Python Commands
.PHONY: py-dev
py-dev:  ## Install Python package in development mode
	@echo "$(BLUE)Installing Python package in development mode...$(NC)"
	$(MATURIN) develop
	@echo "$(GREEN)Python package installed$(NC)"

.PHONY: py-build
py-build:  ## Build Python package
	@echo "$(BLUE)Building Python package...$(NC)"
	$(MATURIN) build
	@echo "$(GREEN)Python package built$(NC)"

.PHONY: py-clean
py-clean:  ## Clean Python build artifacts
	@echo "$(BLUE)Cleaning Python build artifacts...$(NC)"
	rm -rf build/ dist/ *.egg-info/ .mypy_cache/ .pytest_cache/ .coverage htmlcov/
	find . -type d -name "__pycache__" -exec rm -rf {} + 2>/dev/null || true
	find . -type f -name "*.pyc" -delete
	@echo "$(GREEN)Python build artifacts cleaned$(NC)"

.PHONY: py-lint
py-lint:  ## Run Python linters
	@echo "$(BLUE)Running Python linters...$(NC)"
	$(UV) run black --check python/ tests/ examples/
	$(UV) run ruff check python/ tests/ examples/
	$(UV) run mypy python/ tests/ examples/
	@echo "$(GREEN)Python linting completed$(NC)"

.PHONY: py-format
py-format:  ## Format Python code
	@echo "$(BLUE)Formatting Python code...$(NC)"
	$(UV) run black python/ tests/ examples/
	$(UV) run ruff check --fix python/ tests/ examples/
	@echo "$(GREEN)Python code formatted$(NC)"

.PHONY: py-shell
py-shell:  ## Start Python shell with package loaded
	@echo "$(BLUE)Starting Python shell...$(NC)"
	$(UV) run ipython

# Rust Commands
.PHONY: rust-deps
rust-deps:  ## Install Rust dependencies
	@echo "$(BLUE)Installing Rust dependencies...$(NC)"
	$(CARGO) fetch
	@echo "$(GREEN)Rust dependencies installed$(NC)"

.PHONY: rust-build
rust-build:  ## Build Rust project
	@echo "$(BLUE)Building Rust project...$(NC)"
	$(CARGO) build
	@echo "$(GREEN)Rust project built$(NC)"

.PHONY: rust-build-release
rust-build-release:  ## Build Rust project in release mode
	@echo "$(BLUE)Building Rust project (release)...$(NC)"
	$(CARGO) build --release
	@echo "$(GREEN)Rust release build completed$(NC)"

.PHONY: rust-clean
rust-clean:  ## Clean Rust build artifacts
	@echo "$(BLUE)Cleaning Rust build artifacts...$(NC)"
	$(CARGO) clean
	@echo "$(GREEN)Rust build artifacts cleaned$(NC)"

.PHONY: rust-doc
rust-doc:  ## Generate Rust documentation
	@echo "$(BLUE)Generating Rust documentation...$(NC)"
	$(CARGO) doc --no-deps --open
	@echo "$(GREEN)Rust documentation generated$(NC)"

.PHONY: rust-clippy
rust-clippy:  ## Run Rust clippy linter
	@echo "$(BLUE)Running Rust clippy...$(NC)"
	$(CARGO) clippy -- -D warnings
	@echo "$(GREEN)Rust clippy completed$(NC)"

.PHONY: rust-fmt
rust-fmt:  ## Format Rust code
	@echo "$(BLUE)Formatting Rust code...$(NC)"
	$(CARGO) fmt
	@echo "$(GREEN)Rust code formatted$(NC)"

.PHONY: rust-fmt-check
rust-fmt-check:  ## Check Rust code formatting
	@echo "$(BLUE)Checking Rust code formatting...$(NC)"
	$(CARGO) fmt -- --check
	@echo "$(GREEN)Rust formatting check completed$(NC)"

# Testing
.PHONY: test
test: test-rust test-python  ## Run all tests

.PHONY: test-rust
test-rust:  ## Run Rust tests
	@echo "$(BLUE)Running Rust tests...$(NC)"
	$(CARGO) test
	@echo "$(GREEN)Rust tests completed$(NC)"

.PHONY: test-python
test-python:  ## Run Python tests
	@echo "$(BLUE)Running Python tests...$(NC)"
	$(UV) run pytest tests/ -v --cov=$(PYTHON_PACKAGE_NAME) --cov-report=html
	@echo "$(GREEN)Python tests completed$(NC)"

.PHONY: test-python-fast
test-python-fast:  ## Run Python tests without coverage
	@echo "$(BLUE)Running Python tests (fast)...$(NC)"
	$(UV) run pytest tests/ -v
	@echo "$(GREEN)Python tests completed$(NC)"

.PHONY: test-examples
test-examples:  ## Test example code
	@echo "$(BLUE)Testing examples...$(NC)"
	$(UV) run python examples/training_data_generation.py --dry-run
	@echo "$(GREEN)Example tests completed$(NC)"

.PHONY: test-benchmarks
test-benchmarks:  ## Run benchmarks
	@echo "$(BLUE)Running benchmarks...$(NC)"
	$(CARGO) bench
	$(UV) run python benchmarks/python_performance.py
	@echo "$(GREEN)Benchmarks completed$(NC)"

# Build & Distribution
.PHONY: build
build: rust-build-release py-build  ## Build both Rust and Python packages

.PHONY: dist
dist:  ## Build distribution packages
	@echo "$(BLUE)Building distribution packages...$(NC)"
	$(MATURIN) build --release
	@echo "$(GREEN)Distribution packages built$(NC)"

.PHONY: dist-rust
dist-rust:  ## Build Rust distribution
	@echo "$(BLUE)Building Rust distribution...$(NC)"
	$(CARGO) build --release
	@echo "$(GREEN)Rust distribution built$(NC)"

.PHONY: dist-python
dist-python:  ## Build Python wheels
	@echo "$(BLUE)Building Python wheels...$(NC)"
	$(MATURIN) build --release
	@echo "$(GREEN)Python wheels built$(NC)"

.PHONY: release
release: test build  ## Prepare release (run tests and build)
	@echo "$(GREEN)Release preparation completed$(NC)"

.PHONY: release-dry-run
release-dry-run:  ## Dry run release process
	@echo "$(BLUE)Running release dry run...$(NC)"
	$(MAKE) test
	$(MAKE) rust-fmt-check
	$(MAKE) rust-clippy
	$(MAKE) py-lint
	$(MAKE) build
	@echo "$(GREEN)Release dry run completed$(NC)"

# Utility Commands
.PHONY: generate-training-data
generate-training-data:  ## Generate training data samples
	@echo "$(BLUE)Generating training data...$(NC)"
	$(UV) run python examples/training_data_generation.py
	@echo "$(GREEN)Training data generated$(NC)"

.PHONY: run-example
run-example:  ## Run basic packing example
	@echo "$(BLUE)Running packing example...$(NC)"
	$(UV) run python examples/basic_packing.py
	@echo "$(GREEN)Example completed$(NC)"

.PHONY: docker-build
docker-build:  ## Build Docker image
	@echo "$(BLUE)Building Docker image...$(NC)"
	docker build -t $(PROJECT_NAME) .
	@echo "$(GREEN)Docker image built$(NC)"

.PHONY: docker-run
docker-run:  ## Run project in Docker
	@echo "$(BLUE)Running in Docker...$(NC)"
	docker run -it --rm $(PROJECT_NAME)
	@echo "$(GREEN)Docker run completed$(NC)"

# Quality Assurance
.PHONY: qa
qa: rust-fmt-check rust-clippy py-lint test  ## Run all quality checks
	@echo "$(GREEN)All quality checks passed$(NC)"

.PHONY: pre-commit
pre-commit: rust-fmt py-format test  ## Run pre-commit checks
	@echo "$(GREEN)Pre-commit checks completed$(NC)"

# Monitoring
.PHONY: watch-rust
watch-rust:  ## Watch Rust files and run tests on change
	@echo "$(BLUE)Watching Rust files...$(NC)"
	$(CARGO) watch -x test

.PHONY: watch-python
watch-python:  ## Watch Python files and run tests on change
	@echo "$(BLUE)Watching Python files...$(NC)"
	$(UV) run ptw --now .

.PHONY: size
size:  ## Check binary sizes
	@echo "$(BLUE)Binary sizes:$(NC)"
	@ls -lh target/release/$(RUST_PACKAGE_NAME)* 2>/dev/null || echo "No Rust binaries found"
	@ls -lh dist/*.whl 2>/dev/null || echo "No Python wheels found"

# Install development tools
.PHONY: install-tools
install-tools:  ## Install development tools
	@echo "$(BLUE)Installing development tools...$(NC)"
	cargo install cargo-watch
	cargo install cargo-bloat
	$(UV) pip install pre-commit
	@echo "$(GREEN)Development tools installed$(NC)"

# PyPI Educational Stub (safe wheel)
.PHONY: stub-build
stub-build:  ## Build educational stub wheel (PyPI-safe)
	@echo "$(BLUE)Building educational stub wheel...$(NC)"
	@test -d pypi-stub || { echo "missing pypi-stub/"; exit 1; }
	@test -f pypi-stub/pyproject.toml || { echo "missing pypi-stub/pyproject.toml"; exit 1; }
	$(UV) run $(PYTHON) -m pip install --upgrade build
	cd pypi-stub && $(UV) run $(PYTHON) -m build
	@echo "$(GREEN)Stub wheel built in pypi-stub/dist$(NC)"

.PHONY: stub-publish
stub-publish:  ## Publish educational stub to PyPI (requires ALLOW_PYPI_RELEASE=1 and PYPI_TOKEN configured in environment)
	@echo "$(BLUE)Publishing educational stub to PyPI...$(NC)"
	test "$(ALLOW_PYPI_RELEASE)" = "1" || (echo "Set ALLOW_PYPI_RELEASE=1 to enable publishing" && false)
	$(UV) run $(PYTHON) -m pip install --upgrade twine
	cd pypi-stub && $(UV) run $(PYTHON) -m twine upload --non-interactive dist/*
	@echo "$(GREEN)Stub published to PyPI$(NC)"

# MkDocs Documentation
.PHONY: docs-serve
docs-serve:  ## Serve MkDocs locally at http://127.0.0.1:8000
	@echo "$(BLUE)Starting MkDocs dev server...$(NC)"
	$(UV) run $(PYTHON) -m pip install -q mkdocs-material
	$(UV) run mkdocs serve --watch .

.PHONY: docs-build
docs-build:  ## Build MkDocs site into ./site
	@echo "$(BLUE)Building MkDocs site...$(NC)"
	$(UV) run $(PYTHON) -m pip install -q mkdocs-material
	$(UV) run mkdocs build --strict
	@echo "$(GREEN)Docs built in ./site$(NC)"