Makefile

SHELL := /bin/bash
.SHELLFLAGS := -eu -o pipefail -c

DEFAULT_GOAL := help

EXAMPLE ?= dmcc
PROBLEM ?=
IMAGE ?= $(EXAMPLE)-local
PLATFORM ?= linux/amd64
RUNTIME ?= runc
BUILD_ARGS ?=
ENV_FILE ?= .env

EXAMPLE_DIR = examples/$(EXAMPLE)
METADATA_FILE = $(EXAMPLE_DIR)/problems-metadata.json
CORE_PYTHON = taiga-core/.venv/bin/python
CORE_PYTEST = taiga-core/.venv/bin/pytest
EXAMPLES := $(sort $(foreach file,$(wildcard examples/*/Dockerfile),$(notdir $(patsubst %/,%,$(dir $(file))))))

.PHONY: help check-uv check-docker check-jq check-example check-core-env
.PHONY: setup setup-core setup-tunnel tunnel-login
.PHONY: test test-core test-all test-consistency
.PHONY: examples example-info example-prepare example-build example-validate example-run example-shell

help: ## Pokaż dostępne komendy
	@echo "Taiga Local — podstawowe komendy"
	@echo
	@echo "Konfiguracja:"
	@echo "  make setup                         Instalacja taiga-core[dev] i local tunnel"
	@echo "  make setup-core                    Instalacja zależności testowych (bez uv.lock)"
	@echo "  make setup-tunnel                  Instalacja taiga-local-tunnel"
	@echo "  make tunnel-login                  Logowanie do taiga.ant.dev"
	@echo
	@echo "Testy:"
	@echo "  make test                          Stabilne testy jednostkowe taiga-core"
	@echo "  make test-all                      Wszystkie testy poza validate_env"
	@echo "  make test-consistency              Spójność Dockerfile wszystkich przykładów"
	@echo
	@echo "Przykłady (domyślnie EXAMPLE=$(EXAMPLE)):"
	@echo "  make examples                      Lista przykładów i problemów"
	@echo "  make example-info EXAMPLE=dmcc     Szczegóły wybranego przykładu"
	@echo "  make example-prepare EXAMPLE=dmcc  Przygotowanie danych, jeśli wymagane"
	@echo "  make example-build EXAMPLE=dmcc    Budowa obrazu"
	@echo "  make example-validate EXAMPLE=dmcc Walidacja MCP lokalnego obrazu"
	@echo "  make example-run EXAMPLE=dmcc PROBLEM=python1575a"
	@echo "                                      Sesja przez taiga-local-tunnel"
	@echo "  make example-shell EXAMPLE=dmcc    Interaktywny shell w obrazie"
	@echo
	@echo "Opcjonalne zmienne:"
	@echo "  IMAGE=dmcc-local                   Nazwa lokalnego obrazu"
	@echo "  PLATFORM=linux/amd64               Platforma obrazu"
	@echo "  RUNTIME=runc                       Runtime używany przez walidację"
	@echo "  BUILD_ARGS='--build-arg X=Y'       Dodatkowe argumenty docker build"
	@echo "  ENV_FILE=.env                      Plik zmiennych dla local tunnel"

check-uv:
	@command -v uv >/dev/null || { echo "Błąd: zainstaluj uv."; exit 1; }

check-docker:
	@command -v docker >/dev/null || { echo "Błąd: zainstaluj Docker."; exit 1; }
	@docker info >/dev/null || { echo "Błąd: demon Docker nie jest dostępny."; exit 1; }

check-jq:
	@command -v jq >/dev/null || { echo "Błąd: zainstaluj jq."; exit 1; }

check-example:
	@case " $(EXAMPLES) " in *" $(EXAMPLE) "*) ;; \
		*) echo "Błąd: nieznany EXAMPLE='$(EXAMPLE)'."; echo "Użyj: make examples"; exit 1 ;; \
	esac
	@test -f "$(METADATA_FILE)" || { echo "Błąd: brak $(METADATA_FILE)."; exit 1; }

check-core-env:
	@test -x "$(CORE_PYTEST)" || { \
		echo "Błąd: brak środowiska testowego. Uruchom: make setup-core"; \
		exit 1; \
	}

setup: setup-core setup-tunnel ## Zainstaluj podstawowe narzędzia deweloperskie

setup-core: check-uv ## Przygotuj taiga-core/.venv bez generowania uv.lock
	@test -x "$(CORE_PYTHON)" || uv venv taiga-core/.venv
	uv pip install --python "$(CORE_PYTHON)" -e "./taiga-core[dev]"

setup-tunnel: check-uv ## Zainstaluj CLI local tunnel jako narzędzie uv
	uv tool install --force --editable ./local-tunnel

tunnel-login: ## Zaloguj local tunnel do taiga.ant.dev
	@command -v taiga-local-tunnel >/dev/null || { \
		echo "Błąd: uruchom najpierw: make setup-tunnel"; \
		exit 1; \
	}
	@set -a; \
	if [[ -f "$(ENV_FILE)" ]]; then source "$(ENV_FILE)"; fi; \
	set +a; \
	taiga-local-tunnel login

test: test-core ## Uruchom podstawowe testy repozytorium

test-core: check-core-env ## Uruchom testy jednostkowe niezależne od obrazów
	"$(CORE_PYTEST)" taiga-core/tests -m "not validate_env" \
		--ignore=taiga-core/tests/test_docker_usage.py \
		--ignore=taiga-core/tests/test_dockerfile_consistency.py

test-all: check-core-env ## Uruchom wszystkie testy taiga-core poza validate_env
	"$(CORE_PYTEST)" taiga-core/tests -m "not validate_env"

test-consistency: check-core-env ## Sprawdź wspólne sekcje Dockerfile
	"$(CORE_PYTEST)" taiga-core/tests/test_dockerfile_consistency.py

examples: check-jq ## Wyświetl przykłady i dostępne identyfikatory problemów
	@for example in $(EXAMPLES); do \
		metadata="examples/$$example/problems-metadata.json"; \
		if [[ -f "$$metadata" ]]; then \
			problems="$$(jq -r '[.problem_set.problems[].id] | join(", ")' "$$metadata")"; \
			printf "%-28s %s\n" "$$example" "$$problems"; \
		fi; \
	done

example-info: check-example check-jq ## Pokaż konfigurację wybranego przykładu
	@echo "Example:  $(EXAMPLE)"
	@echo "Directory: $(EXAMPLE_DIR)"
	@echo "Image:    $(IMAGE)"
	@echo "Problems:"
	@jq -r '.problem_set.problems[] | "  - \(.id) [\(.required_tools | join(", "))]"' "$(METADATA_FILE)"

example-prepare: check-example check-uv ## Przygotuj dane wymagane przez przykład
	@if [[ -f "$(EXAMPLE_DIR)/prepare_dataset.py" ]]; then \
		echo "Przygotowuję dane dla $(EXAMPLE)..."; \
		if [[ "$(EXAMPLE)" == "dmcc" ]]; then \
			cd "$(EXAMPLE_DIR)" && uv run --no-project --with "datasets>=3.4.1" python prepare_dataset.py; \
		else \
			echo "Błąd: brak zdefiniowanych zależności dla $(EXAMPLE_DIR)/prepare_dataset.py."; \
			exit 1; \
		fi; \
	else \
		echo "Przykład $(EXAMPLE) nie wymaga kroku prepare."; \
	fi

example-build: check-example check-docker ## Zbuduj obraz wybranego przykładu
	@if [[ -x "$(EXAMPLE_DIR)/build.sh" ]]; then \
		echo "Przykład $(EXAMPLE) używa własnego procesu budowania:"; \
		cd "$(EXAMPLE_DIR)" && ./build.sh; \
	else \
		cd "$(EXAMPLE_DIR)" && docker build \
			--build-context taiga=../.. \
			--platform "$(PLATFORM)" \
			$(BUILD_ARGS) \
			-t "$(IMAGE)" \
			-f Dockerfile \
			.; \
	fi

example-validate: check-example check-docker check-jq check-core-env ## Zweryfikuj lokalny obraz przez pytest validate_env
	@metadata="$$(mktemp /tmp/taiga-metadata.XXXXXX.json)"; \
	trap 'rm -f "$$metadata"' EXIT; \
	jq --arg image "$(IMAGE)" --arg root "$(abspath $(EXAMPLE_DIR))/" \
		'(.problem_set.problems[].image) = $$image | (.problem_set.problems[] | select(.preloaded_files != null) | .preloaded_files[].local_path) |= if startswith("/") then . else $$root + . end' \
		"$(METADATA_FILE)" > "$$metadata"; \
	CONTAINER_RUNTIME="$(RUNTIME)" "$(CORE_PYTEST)" taiga-core/tests -m validate_env \
		--problems-metadata-path="$$metadata" -v -s

example-run: check-example check-docker check-jq ## Uruchom przykład przez local tunnel
	@command -v taiga-local-tunnel >/dev/null || { \
		echo "Błąd: uruchom najpierw: make setup-tunnel"; \
		exit 1; \
	}
	@problem="$(PROBLEM)"; \
	if [[ -z "$$problem" ]]; then \
		problem="$$(jq -r '.problem_set.problems[0].id' "$(METADATA_FILE)")"; \
	fi; \
	echo "Uruchamiam $(EXAMPLE), problem=$$problem, image=$(IMAGE)"; \
	set -a; \
	if [[ -f "$(ENV_FILE)" ]]; then source "$(ENV_FILE)"; fi; \
	set +a; \
	taiga-local-tunnel start \
		--image "$(IMAGE)" \
		--metadata-file "$(METADATA_FILE)" \
		--problem-id "$$problem"

example-shell: check-example check-docker ## Otwórz shell w lokalnym obrazie
	docker run --rm -it --platform "$(PLATFORM)" "$(IMAGE)" bash