Taskfile.yml

version: "3"

vars:
  API_DIR: apps/api
  WEB_DIR: apps/web
  DOCKER_COMPOSE: infrastructure/docker/docker-compose.yml
  INFRA_DIR: infrastructure/terraform

tasks:
  check:
    desc: Check prerequisites — detect missing tools with install instructions
    silent: true
    cmds:
      - |
        missing=0

        check_tool() {
          if command -v "$1" &> /dev/null; then
            printf "  ✓ %-10s %s\n" "$1" "$(eval "$3")"
          else
            printf "  ✗ %-10s missing — install with: %s\n" "$1" "$2"
            missing=$((missing + 1))
          fi
        }

        echo "Checking prerequisites..."
        echo ""
        check_tool "docker"  "brew install --cask docker"       "docker --version | head -1"
        check_tool "node"    "nvm install 24"                   "node --version"
        check_tool "pnpm"    "npm install -g pnpm"              "pnpm --version"
        check_tool "java"    "sdk install java 25-open"         "java --version 2>&1 | head -1"
        check_tool "lefthook" "brew install lefthook"            "lefthook version"
        echo ""

        if [ "$missing" -gt 0 ]; then
          echo "⚠ $missing tool(s) missing. Install them and re-run: task check"
          exit 1
        else
          echo "All prerequisites installed."
        fi

  setup:
    desc: Full-stack setup — copy env templates, install web dependencies, install git hooks
    cmds:
      - task: setup:api
      - task: setup:infra
      - task: setup:web
      - task: setup:hooks

  setup:hooks:
    desc: Install git hooks via Lefthook
    cmds:
      - |
        if command -v lefthook &> /dev/null; then
          lefthook install
          echo "Git hooks installed via Lefthook"
        else
          echo "Warning: lefthook is not installed. Install with: brew install lefthook"
        fi

  setup:api:
    desc: API setup — copy env and config templates if missing
    cmds:
      - |
        if [ ! -f {{.API_DIR}}/.env.local ]; then
          cp {{.API_DIR}}/.env.local.example {{.API_DIR}}/.env.local
          echo "Created {{.API_DIR}}/.env.local from template"
        else
          echo "{{.API_DIR}}/.env.local already exists, skipping"
        fi
      - |
        if [ ! -f {{.API_DIR}}/src/main/resources/application-local.yml ]; then
          cp {{.API_DIR}}/src/main/resources/application-local.yml.example {{.API_DIR}}/src/main/resources/application-local.yml
          echo "Created {{.API_DIR}}/src/main/resources/application-local.yml from template"
        else
          echo "{{.API_DIR}}/src/main/resources/application-local.yml already exists, skipping"
        fi

  setup:infra:
    desc: Infrastructure setup — copy Terraform tfvars template if missing
    cmds:
      - |
        if [ ! -f {{.INFRA_DIR}}/terraform.tfvars ]; then
          cp {{.INFRA_DIR}}/terraform.tfvars.example {{.INFRA_DIR}}/terraform.tfvars
          echo "Created {{.INFRA_DIR}}/terraform.tfvars from template"
        else
          echo "{{.INFRA_DIR}}/terraform.tfvars already exists, skipping"
        fi

  setup:web:
    desc: Web setup — copy .env.local template if missing, install dependencies
    cmds:
      - |
        if [ ! -f {{.WEB_DIR}}/.env.local ]; then
          cp {{.WEB_DIR}}/.env.local.example {{.WEB_DIR}}/.env.local
          echo "Created {{.WEB_DIR}}/.env.local from template"
        else
          echo "{{.WEB_DIR}}/.env.local already exists, skipping"
        fi
      - cd {{.WEB_DIR}} && pnpm install

  setup:mock:
    desc: Mock-mode setup — copy mock env template, install dependencies
    cmds:
      - cp {{.WEB_DIR}}/.env.local.mock {{.WEB_DIR}}/.env.local
      - echo "Created {{.WEB_DIR}}/.env.local for mock mode"
      - cd {{.WEB_DIR}} && pnpm install

  dev:
    desc: Full-stack dev — start API (auto-starts postgres) + web in parallel
    deps:
      - dev:api
      - dev:web

  dev:api:
    desc: Start API server — auto-starts postgres via spring-boot-docker-compose
    dir: "{{.API_DIR}}"
    cmds:
      - ./gradlew bootRun --args='--spring.profiles.active=local'

  dev:web:
    desc: Start web dev server with Turbopack
    dir: "{{.WEB_DIR}}"
    env:
      WATCHPACK_POLLING: "true"
      CHOKIDAR_USEPOLLING: "true"
    cmds:
      - pnpm run dev

  dev:db:
    desc: Start database only — useful when backend is not needed
    cmds:
      - docker compose -f {{.DOCKER_COMPOSE}} up -d

  db:reset:
    desc: Reset the database (WARNING — destroys all data)
    cmds:
      - docker compose -f {{.DOCKER_COMPOSE}} down -v
      - docker compose -f {{.DOCKER_COMPOSE}} up -d db

  test:
    desc: Run all tests — API + web
    cmds:
      - task: test:api
      - task: test:web

  test:api:
    desc: Run API tests (uses Testcontainers, not Docker Compose)
    dir: "{{.API_DIR}}"
    cmds:
      - ./gradlew test

  test:web:
    desc: Run web lint, typecheck, and unit tests
    dir: "{{.WEB_DIR}}"
    cmds:
      - pnpm run lint
      - npx tsc --noEmit
      - pnpm run test:unit

  lint:
    desc: Run all linters — ktlint + ESLint
    cmds:
      - task: lint:api
      - task: lint:web

  lint:api:
    desc: Run Kotlin linter (ktlint)
    dir: "{{.API_DIR}}"
    cmds:
      - ./gradlew ktlintCheck

  lint:web:
    desc: Run ESLint
    dir: "{{.WEB_DIR}}"
    cmds:
      - pnpm run lint

  stop:
    desc: Stop database container
    cmds:
      - docker compose -f {{.DOCKER_COMPOSE}} down

  clean:
    desc: Clean build artifacts
    cmds:
      - task: clean:api
      - task: clean:web

  clean:api:
    desc: Clean API build artifacts
    dir: "{{.API_DIR}}"
    cmds:
      - ./gradlew clean

  clean:web:
    desc: Clean web build artifacts
    dir: "{{.WEB_DIR}}"
    cmds:
      - rm -rf .next .velite