BINARY := anubis

VERSION := $(shell git describe --tags --always --dirty 2>/dev/null || echo "dev")

COMMIT := $(shell git rev-parse --short HEAD 2>/dev/null || echo "unknown")

DATE := $(shell date -u +%Y-%m-%dT%H:%M:%SZ)

LDFLAGS := -s -w \

-X main.Version=$(VERSION) \

-X main.Commit=$(COMMIT) \

-X main.BuildDate=$(DATE)

.PHONY: all build clean test test-coverage test-short benchmark lint dashboard dashboard-coverage dashboard-api-types dashboard-check-api run docker preflight-production smoke-production capture-production-evidence docs help

all: dashboard build ## Build dashboard and binary

build: ## Build the anubis binary

@echo "⚖️ Building AnubisWatch..."

CGO_ENABLED=0 go build -ldflags "$(LDFLAGS)" -o bin/$(BINARY) ./cmd/anubis

@echo "✓ Build complete: bin/$(BINARY)"

run: build ## Build and run the server

./bin/$(BINARY) serve

dev: ## Run in development mode (single node, no TLS)

go run ./cmd/anubis serve --single --config ./configs/anubis.yaml

clean: ## Clean build artifacts

rm -rf bin/ web/dist/

@echo "✓ Cleaned"

test: ## Run all tests

go test -race ./cmd/... ./internal/...

test-coverage: ## Enforce exact Go coverage for cmd and internal packages

./scripts/check-go-coverage.sh

test-short: ## Run short tests only

go test -short ./...

benchmark: ## Run benchmarks (storage and probe)

@echo "⚖️ Running benchmarks..."

go test -bench=. -benchmem ./internal/storage/...

go test -bench=. -benchmem ./internal/probe/...

preflight-production: ## Run production Helm/Kubernetes preflight checks (requires VALUES)

./scripts/production-preflight.sh

smoke-production: ## Run production smoke checks (requires ANUBIS_BASE_URL or BASE_URL arg)

./scripts/production-smoke.sh $(BASE_URL)

capture-production-evidence: ## Capture deployment evidence for the current Kubernetes context

./scripts/capture-deployment-evidence.sh $(OUTPUT_DIR)

GOLANGCI_LINT_VERSION ?= v2.15.0

lint: ## Run golangci-lint (same version and config as CI)

go run github.com/golangci/golangci-lint/v2/cmd/golangci-lint@$(GOLANGCI_LINT_VERSION) run --timeout=5m ./...

fmt: ## Format Go code

go fmt ./...

vet: ## Run go vet

go vet ./...

dashboard: ## Build React dashboard

@echo "⚖️ Building dashboard..."

cd web && pnpm install --frozen-lockfile && pnpm run check:api && pnpm run build:embed

@echo "✓ Dashboard built"

dashboard-api-types: ## Regenerate web/src/api/schema.generated.ts from the OpenAPI spec

cd web && pnpm run gen:api

dashboard-check-api: ## Fail if the dashboard API types are stale against the OpenAPI spec

cd web && pnpm run check:api

dashboard-dev: ## Run dashboard dev server

cd web && pnpm run dev

dashboard-coverage: ## Enforce exact dashboard coverage

cd web && pnpm run test:coverage

build-all: ## Build for all platforms

$(MAKE) build-linux-amd64

$(MAKE) build-linux-arm64

$(MAKE) build-linux-armv7

$(MAKE) build-darwin-amd64

$(MAKE) build-darwin-arm64

$(MAKE) build-windows-amd64

$(MAKE) build-freebsd-amd64

build-linux-amd64:

@echo "Building for linux/amd64..."

GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -ldflags "$(LDFLAGS)" -o bin/$(BINARY)-linux-amd64 ./cmd/anubis

build-linux-arm64:

@echo "Building for linux/arm64..."

GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -ldflags "$(LDFLAGS)" -o bin/$(BINARY)-linux-arm64 ./cmd/anubis

build-linux-armv7:

@echo "Building for linux/armv7..."

GOOS=linux GOARCH=arm GOARM=7 CGO_ENABLED=0 go build -ldflags "$(LDFLAGS)" -o bin/$(BINARY)-linux-armv7 ./cmd/anubis

build-darwin-amd64:

@echo "Building for darwin/amd64..."

GOOS=darwin GOARCH=amd64 CGO_ENABLED=0 go build -ldflags "$(LDFLAGS)" -o bin/$(BINARY)-darwin-amd64 ./cmd/anubis

build-darwin-arm64:

@echo "Building for darwin/arm64..."

GOOS=darwin GOARCH=arm64 CGO_ENABLED=0 go build -ldflags "$(LDFLAGS)" -o bin/$(BINARY)-darwin-arm64 ./cmd/anubis

build-windows-amd64:

@echo "Building for windows/amd64..."

GOOS=windows GOARCH=amd64 CGO_ENABLED=0 go build -ldflags "$(LDFLAGS)" -o bin/$(BINARY)-windows-amd64.exe ./cmd/anubis

build-freebsd-amd64:

@echo "Building for freebsd/amd64..."

GOOS=freebsd GOARCH=amd64 CGO_ENABLED=0 go build -ldflags "$(LDFLAGS)" -o bin/$(BINARY)-freebsd-amd64 ./cmd/anubis

IMAGE ?= ghcr.io/anubiswatch/anubiswatch

docker: ## Build Docker image ($(IMAGE))

docker build \

--build-arg VERSION=$(VERSION) \

--build-arg COMMIT=$(COMMIT) \

--build-arg BUILD_DATE=$(DATE) \

-t $(IMAGE):$(VERSION) .

docker tag $(IMAGE):$(VERSION) $(IMAGE):latest

docker-push: docker ## Push Docker image to ghcr.io

docker push $(IMAGE):$(VERSION)

docker push $(IMAGE):latest

release: clean dashboard build-all ## Prepare release artifacts

@echo "⚖️ Creating release artifacts..."

mkdir -p dist

for f in bin/$(BINARY)-*; do \

name=$$(basename $$f); \

cp $$f dist/$$name; \

tar -czf dist/$$name.tar.gz -C bin $$(basename $$f); \

done

@echo "✓ Release artifacts in dist/"

init: ## Initialize default config

./bin/$(BINARY) init

watch: ## Quick-add a monitor (requires TARGET)

./bin/$(BINARY) watch $(TARGET)

judge: ## Show current judgments

./bin/$(BINARY) judge

deps: ## Download and verify dependencies

go mod download

go mod verify

deps-update: ## Update dependencies

go get -u ./...

go mod tidy

tidy: ## Tidy go modules

go mod tidy

docs: ## List the documentation

@echo "Documentation index: docs/INDEX.md"

@echo "API reference: docs/API.md (OpenAPI: internal/api/openapi.yaml, served at /api/docs)"

@echo "Configuration: docs/CONFIGURATION.md"

help: ## Show this help

@echo "AnubisWatch — The Judgment Never Sleeps"

@echo ""

@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf " \033[36m%-15s\033[0m %s\n", $$1, $$2}'

.DEFAULT_GOAL := help