Skip to main content

Makefile Commands Reference

Complete reference for all Makefile commands available in the Boards monorepo.

Quick Reference​

make help    # Show all available commands with descriptions

Installation & Setup​

make install​

Install all dependencies (Python and Node.js packages).

make install

Equivalent to running both make install-backend and make install-frontend.

make install-backend​

Install only Python backend dependencies using uv.

make install-backend

make install-frontend​

Install only Node.js frontend dependencies using pnpm.

make install-frontend

Development Servers​

make dev​

Start all development servers in parallel:

make dev

make dev-backend​

Start only the backend development server with auto-reload.

make dev-backend

make dev-frontend​

Start only frontend development servers (all frontend packages).

make dev-frontend

make dev-worker​

Start the background worker for processing generation jobs.

make dev-worker

make dev-worker-watch​

Start the background worker with auto-reload on file changes (requires entr).

# Install entr first: brew install entr
make dev-worker-watch

Code Quality​

make format​

NEW - Format all code (both Python and Node.js). Runs auto-fixers for linting and formatting issues.

make format

This runs:

  • ruff check --fix and ruff format on Python code
  • ESLint with --fix on TypeScript/JavaScript code

Recommended: Run this before committing to avoid pre-commit hook failures.

make format-backend​

Format only Python backend code with ruff.

make format-backend

make format-frontend​

Format only frontend Node.js code with ESLint.

make format-frontend

make lint​

Run all linters (both Python and Node.js).

make lint

make lint-backend​

Run ruff linter and pyright type checker on Python code.

make lint-backend

make lint-frontend​

Run ESLint on all frontend packages.

make lint-frontend

make typecheck​

Run type checking for all packages (Python and TypeScript).

make typecheck

make typecheck-backend​

Run pyright type checker on Python code.

make typecheck-backend

make typecheck-frontend​

Run TypeScript type checker on frontend packages.

make typecheck-frontend

Testing​

make test​

Run all tests (both Python and Node.js).

make test

make test-backend​

Run Python backend tests with pytest. Excludes live API tests by default.

make test-backend

In CI environments, also excludes Redis-dependent tests.

make test-frontend​

Run frontend tests with vitest.

make test-frontend

Building​

make build​

Build all packages (both Python and Node.js).

make build

make build-backend​

Build only the Python backend package.

make build-backend

make build-frontend​

Build only frontend Node.js packages using Turborepo.

make build-frontend

make build-cli-launcher​

Build the CLI launcher package.

make build-cli-launcher

Documentation​

make docs or make dev-docs​

Start the documentation development server at http://localhost:4500.

make docs

make build-docs​

Build documentation for production.

make build-docs

make serve-docs​

Serve built documentation locally.

make serve-docs

Docker Services​

make docker-up​

Start Docker services (PostgreSQL and Redis).

make docker-up

make docker-down​

Stop Docker services.

make docker-down

make docker-logs​

View logs from Docker services.

make docker-logs

make docker-clean​

Clean and restart Docker services with fresh containers.

make docker-clean

Database​

make upgrade-db​

Run database migrations (Alembic upgrade head).

make upgrade-db

For more database operations, see the Database Migrations guide.

Cleanup​

make clean​

Clean all build artifacts and caches (both Python and Node.js).

make clean

make clean-backend​

Clean only Python backend artifacts:

  • __pycache__ directories
  • .egg-info directories
  • dist and build directories
  • .pytest_cache, .mypy_cache, .ruff_cache
make clean-backend

make clean-frontend​

Clean only frontend Node.js artifacts:

  • node_modules directories
  • .next directories
  • .turbo cache
make clean-frontend

Common Workflows​

Starting Fresh Development​

make install          # Install dependencies
make docker-up        # Start PostgreSQL and Redis
make upgrade-db       # Run database migrations
make dev              # Start all dev servers

Pre-commit Checks​

make format           # Format code (auto-fix issues)
make test             # Run all tests
make lint             # Check for remaining issues
make typecheck        # Verify types

Building for Production​

make clean            # Clean old artifacts
make build            # Build all packages
make test             # Verify everything works

Tips​

  • Use make help to see all available commands with descriptions
  • Run make format before committing to avoid pre-commit hook failures
  • Use parallel commands like make dev instead of running servers separately
  • Check Docker services with make docker-logs if you encounter connection issues