Taskfile.yml

version: "3"

tasks:
  default:
    desc: List available tasks
    cmds:
      - task --list

  build:
    desc: Build detected projects and run lightweight compile checks
    cmds:
      - task: _go_smoke
        vars:
          GO_ARGS: test -run '^$' ./tests
      - task: _rust
        vars:
          KIND: build
          ARGS: check --workspace
      - task: _js
        vars:
          KIND: build
          SCRIPTS: build
      - task: _python_syntax

  test:
    desc: Run detected project tests
    cmds:
      - task: _go_smoke
        vars:
          GO_ARGS: test ./tests
      - task: _rust
        vars:
          KIND: test
          ARGS: test --workspace
      - task: _js
        vars:
          KIND: test
          SCRIPTS: test:ci test
      - task: _python
        vars:
          KIND: test
          CMD: run pytest

  lint:
    desc: Run detected project linters
    cmds:
      - task: _go_lint
      - task: _rust
        vars:
          KIND: lint
          ARGS: fmt --all -- --check
      - task: _rust
        vars:
          KIND: lint
          ARGS: clippy --workspace --all-targets -- -D warnings
      - task: _js
        vars:
          KIND: lint
          SCRIPTS: check:lint lint check
      - task: _python
        vars:
          KIND: lint
          CMD: run ruff check .

  clean:
    desc: Remove common build and test artifacts
    cmds:
      - task: _js
        vars:
          KIND: clean
          SCRIPTS: clean
      - task: _python
        vars:
          KIND: clean
          CMD: cache clean
      - |
          find . \
            \( -path '*/.git' -o -path '*/node_modules' -o -path '*/.venv' \) -prune \
            -o \( -name dist -o -name build -o -name coverage -o -name .turbo \
              -o -name .next -o -name .react-router -o -name .vite \
              -o -name .vitest -o -name .pytest_cache -o -name .ruff_cache \
              -o -name .cache -o -name __pycache__ -o -name target \) -type d -print \
            | while IFS= read -r path; do
                rm -rf "$path"
              done

  _go_smoke:
    internal: true
    silent: true
    cmds:
      - |
          set -eu

          if find tests -name '*_test.go' -type f | grep -q .; then
            cache_dir="${TMPDIR:-/tmp}/phenoproject-go-build-cache"
            mkdir -p "$cache_dir"
            echo "go: GO111MODULE=off GOCACHE=$cache_dir go {{.GO_ARGS}}"
            GO111MODULE=off GOCACHE="$cache_dir" go {{.GO_ARGS}}
          fi

  _go_lint:
    internal: true
    silent: true
    cmds:
      - |
          set -eu

          go_files=$(find . \
            \( -path '*/.git' -o -path '*/node_modules' -o -path '*/vendor' \) -prune \
            -o -name '*.go' -type f -print)
          if [ -z "$go_files" ]; then
            exit 0
          fi

          unformatted=$(gofmt -l $go_files)
          if [ -n "$unformatted" ]; then
            echo "go: gofmt required for:"
            echo "$unformatted"
            exit 1
          fi

          echo "go: gofmt check passed"

  _rust:
    internal: true
    silent: true
    cmds:
      - |
          set -eu

          if ! command -v cargo >/dev/null 2>&1; then
            echo "{{.KIND}}: skipping Rust projects (cargo not installed)"
            exit 0
          fi

          has_parent_cargo() {
            dir=$(dirname "$(dirname "$1")")
            while [ "$dir" != "." ] && [ "$dir" != "/" ]; do
              if [ -f "$dir/Cargo.toml" ]; then
                return 0
              fi
              dir=$(dirname "$dir")
            done
            return 1
          }

          find . \
            -maxdepth 4 \
            \( -path '*/.git' -o -path '*/node_modules' -o -path '*/target' \) -prune \
            -o -name Cargo.toml -type f -print \
            | sort \
            | while IFS= read -r manifest; do
              if has_parent_cargo "$manifest"; then
                continue
              fi

              dir=$(dirname "$manifest")
              echo "{{.KIND}}: $dir (cargo {{.ARGS}})"
              (cd "$dir" && cargo {{.ARGS}})
            done

  _js:
    internal: true
    silent: true
    cmds:
      - |
          set -eu

          has_script() {
            node -e 'const fs = require("fs"); const pkg = JSON.parse(fs.readFileSync(process.argv[1], "utf8")); const script = process.argv[2]; process.exit(pkg.scripts && Object.hasOwn(pkg.scripts, script) ? 0 : 1)' "$1" "$2"
          }

          package_manager() {
            dir=$1
            declared_pm=$(node -e 'const fs = require("fs"); const pkg = JSON.parse(fs.readFileSync(process.argv[1], "utf8")); const value = String(pkg.packageManager || "").split("@")[0]; if (value) console.log(value)' "$dir/package.json")
            if [ -n "$declared_pm" ]; then
              echo "$declared_pm"
            elif [ -f "$dir/pnpm-workspace.yaml" ] || [ -f "$dir/pnpm-lock.yaml" ]; then
              echo pnpm
            elif [ -f "$dir/bun.lock" ] || [ -f "$dir/bun.lockb" ]; then
              echo bun
            elif [ -f "$dir/yarn.lock" ]; then
              echo yarn
            else
              echo npm
            fi
          }

          has_lockfile() {
            dir=$1
            [ -f "$dir/package-lock.json" ] \
              || [ -f "$dir/npm-shrinkwrap.json" ] \
              || [ -f "$dir/pnpm-lock.yaml" ] \
              || [ -f "$dir/bun.lock" ] \
              || [ -f "$dir/bun.lockb" ] \
              || [ -f "$dir/yarn.lock" ]
          }

          has_installed_dependencies() {
            dir=$1
            [ -d "$dir/node_modules" ]
          }

          has_parent_package() {
            dir=$(dirname "$(dirname "$1")")
            while [ "$dir" != "." ] && [ "$dir" != "/" ]; do
              if [ -f "$dir/package.json" ]; then
                return 0
              fi
              dir=$(dirname "$dir")
            done
            return 1
          }

          find . \
            \( -path '*/.git' -o -path '*/node_modules' -o -path '*/dist' \
              -o -path '*/build' -o -path '*/.turbo' -o -path '*/.next' \) -prune \
            -o -name package.json -type f -print \
            | sort \
            | while IFS= read -r manifest; do
              if has_parent_package "$manifest"; then
                continue
              fi

              dir=$(dirname "$manifest")
              pm=$(package_manager "$dir")

              if ! has_lockfile "$dir" && ! has_installed_dependencies "$dir"; then
                echo "{{.KIND}}: skipping $dir (no JavaScript lockfile or installed dependencies)"
                continue
              fi

              if ! has_installed_dependencies "$dir"; then
                echo "{{.KIND}}: skipping $dir (dependencies not installed)"
                continue
              fi

              for script in {{.SCRIPTS}}; do
                if has_script "$manifest" "$script"; then
                  echo "{{.KIND}}: $dir ($pm run $script)"
                  (cd "$dir" && "$pm" run "$script")
                  continue 2
                fi
              done

              echo "{{.KIND}}: skipping $dir (no matching package script)"
            done

  _python:
    internal: true
    silent: true
    cmds:
      - |
          set -eu

          if ! command -v uv >/dev/null 2>&1; then
            echo "{{.KIND}}: skipping Python projects (uv not installed)"
            exit 0
          fi

          find . \
            -maxdepth 3 \
            \( -path '*/.git' -o -path '*/node_modules' -o -path '*/.venv' \
              -o -path '*/__pycache__' -o -path '*/.pytest_cache' \) -prune \
            -o -name pyproject.toml -type f -print \
            | sort \
            | while IFS= read -r manifest; do
              dir=$(dirname "$manifest")
              echo "{{.KIND}}: $dir (uv {{.CMD}})"
              (cd "$dir" && uv {{.CMD}})
            done

  _python_syntax:
    internal: true
    silent: true
    cmds:
      - |
          set -eu

          if ! command -v uv >/dev/null 2>&1; then
            echo "build: skipping Python projects (uv not installed)"
            exit 0
          fi

          find . \
            -maxdepth 6 \
            \( -path '*/.git' -o -path '*/node_modules' -o -path '*/.venv' \
              -o -path '*/__pycache__' -o -path '*/.pytest_cache' \) -prune \
            -o -name pyproject.toml -type f -print \
            | sort \
            | while IFS= read -r manifest; do
              dir=$(dirname "$manifest")
              echo "build: $dir (python syntax check)"
              (cd "$dir" && uv run --no-project python - <<'PY'
          import ast
          import pathlib
          import sys

          ignored = {".git", ".venv", "__pycache__", "node_modules"}
          failed = False

          for path in sorted(pathlib.Path(".").rglob("*.py")):
              if any(part in ignored for part in path.parts):
                  continue
              try:
                  ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
              except SyntaxError as exc:
                  failed = True
                  print(f"{path}:{exc.lineno}:{exc.offset}: {exc.msg}", file=sys.stderr)

          raise SystemExit(1 if failed else 0)
          PY
              )
            done