Taskfile.yml

version: '3'
dotenv: ['.env']

vars:
  BINARY_NAME: librecode
  BUILD_DIR: ./bin
  COVERAGE_FILE: coverage.out
  MAIN_PACKAGE: ./cmd/{{.BINARY_NAME}}

env:
  GOCACHE: '{{.ROOT_DIR}}/.gocache'
  GOMODCACHE: '{{.ROOT_DIR}}/.gomodcache'
  GOLANGCI_LINT_CACHE: '{{.ROOT_DIR}}/.tmp/golangci-lint'
  GOTMPDIR: '{{.ROOT_DIR}}/.tmp'
  TMPDIR: '{{.ROOT_DIR}}/.tmp'

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

  ensure-cache:
    internal: true
    cmds:
      - mkdir -p .gocache .gomodcache .tmp .tmp/golangci-lint {{.BUILD_DIR}}

  run:
    desc: Build and run
    deps: [ensure-cache, build]
    cmds:
      - '{{.BUILD_DIR}}/{{.BINARY_NAME}}'

  build:
    desc: Build binary
    deps: [ensure-cache]
    vars:
      VERSION:
        sh: git describe --tags --always --dirty 2>/dev/null || printf dev
      COMMIT:
        sh: git rev-parse --short HEAD 2>/dev/null || printf none
      BUILD_DATE:
        sh: date -u +"%Y-%m-%dT%H:%M:%SZ"
      BUILD_METADATA: '{{.VERSION}}|{{.COMMIT}}|{{.BUILD_DATE}}'
      LDFLAGS: >-
        -X github.com/omarluq/librecode/internal/vinfo.version={{.BUILD_METADATA}}
    cmds:
      - go build -ldflags "{{.LDFLAGS}}" -o {{.BUILD_DIR}}/{{.BINARY_NAME}} {{.MAIN_PACKAGE}}

  clean:
    desc: Clean build artifacts
    cmds:
      - rm -rf {{.BUILD_DIR}}
      - rm -f {{.COVERAGE_FILE}} coverage.html
      - rm -rf .gocache .gomodcache .tmp
      - go clean -cache -testcache

  test:
    desc: Run tests
    deps: [ensure-cache]
    cmds:
      - go test -v -race ./...

  test-short:
    desc: Run short tests
    deps: [ensure-cache]
    cmds:
      - go test -v -race -short ./...

  test-coverage:
    desc: Run tests with coverage
    deps: [ensure-cache]
    cmds:
      - go test -v -race -coverprofile={{.COVERAGE_FILE}} -covermode=atomic ./...
      - go tool cover -html={{.COVERAGE_FILE}} -o coverage.html

  lint:
    desc: Run golangci-lint
    deps: [ensure-cache]
    cmds:
      - golangci-lint run

  fmt:
    desc: Format and fix with golangci-lint
    deps: [ensure-cache]
    cmds:
      - golangci-lint fmt
      - golangci-lint run --fix

  fmt-check:
    desc: Check formatting without modifying files
    deps: [ensure-cache]
    cmds:
      - golangci-lint fmt --diff

  lint-suppressions-check:
    desc: Reject nolint directives in project Go source
    cmds:
      - |
        if git grep -nE '//[[:space:]]*nolint([[:space:]:]|$)' -- '*.go'; then
          echo 'nolint directives are not allowed; fix the underlying lint issue instead' >&2
          exit 1
        fi

  deps:
    desc: Download dependencies
    deps: [ensure-cache]
    cmds:
      - go mod download

  tidy:
    desc: Tidy dependencies
    deps: [ensure-cache]
    cmds:
      - go mod tidy

  hooks-install:
    desc: Install git hooks
    cmds:
      - lefthook install


  ci:
    desc: Run CI checks without modifying files
    cmds:
      - task: fmt-check
      - task: lint-suppressions-check
      - task: lint
      - task: test
      - task: build

  bench:
    desc: Run terminal-bench Harbor benchmark with local librecode auth mounted
    deps: [ensure-cache, build]
    cmds:
      - |
        set -euo pipefail
        AUTH_DIR="${LIBRECODE_BENCH_AUTH_DIR:-${LIBRECODE_HOME:-$HOME/.librecode}}"
        DATASET="${LIBRECODE_BENCH_DATASET:-terminal-bench/terminal-bench-2-1}"
        AGENT_IMPORT_PATH="${LIBRECODE_BENCH_AGENT_IMPORT_PATH:-bench.harbor.librecode_agent:LibrecodeAgent}"
        K="${LIBRECODE_BENCH_K:-5}"
        N="${LIBRECODE_BENCH_N:-4}"
        CONTAINER_HOME="${LIBRECODE_BENCH_CONTAINER_HOME:-/librecode-home}"
        JOBS_DIR="${LIBRECODE_BENCH_JOBS_DIR:-jobs}"
        JOB_NAME="${LIBRECODE_BENCH_JOB_NAME:-}"
        DEBUG="${LIBRECODE_BENCH_DEBUG:-false}"
        LOG_WATCH="${LIBRECODE_BENCH_LOG_WATCH:-false}"
        LOG_WATCH_INTERVAL="${LIBRECODE_BENCH_LOG_WATCH_INTERVAL:-60}"
        SHARD_INDEX="${LIBRECODE_BENCH_SHARD_INDEX:-}"
        SHARD_TOTAL="${LIBRECODE_BENCH_SHARD_TOTAL:-}"
        INCLUDE_TASKS="${LIBRECODE_BENCH_INCLUDE_TASKS:-}"
        EXCLUDE_TASKS="${LIBRECODE_BENCH_EXCLUDE_TASKS:-}"
        N_TASKS="${LIBRECODE_BENCH_N_TASKS:-}"
        TASK_LIST_FILE="${LIBRECODE_BENCH_TASK_LIST_FILE:-}"
        if [ -z "$TASK_LIST_FILE" ] && [ "$DATASET" = "terminal-bench/terminal-bench-2-1" ] && [ -r "bench/terminal-bench-2-1-tasks.txt" ]; then
          TASK_LIST_FILE="bench/terminal-bench-2-1-tasks.txt"
        fi
        TASK_FILTER_PREFIX=""
        if [ -n "${LIBRECODE_BENCH_TASK_PREFIX:-}" ]; then
          TASK_FILTER_PREFIX="$LIBRECODE_BENCH_TASK_PREFIX"
        elif [ -n "${DATASET%%/*}" ] && [ "$DATASET" != "${DATASET%%/*}" ]; then
          TASK_FILTER_PREFIX="${DATASET%%/*}"
        fi
        qualify_task_filter() {
          case "$1" in
            */*) printf '%s\n' "$1" ;;
            *)
              if [ -n "$TASK_FILTER_PREFIX" ]; then
                printf '%s/%s\n' "$TASK_FILTER_PREFIX" "$1"
              else
                printf '%s\n' "$1"
              fi
              ;;
          esac
        }

        if [ ! -d "$AUTH_DIR" ]; then
          echo "librecode auth dir not found: $AUTH_DIR" >&2
          echo "Set LIBRECODE_BENCH_AUTH_DIR to the host directory to copy into the benchmark mount." >&2
          exit 1
        fi
        if [ ! -r "$AUTH_DIR/auth.json" ]; then
          echo "librecode auth file not found or unreadable: $AUTH_DIR/auth.json" >&2
          echo "Set LIBRECODE_BENCH_AUTH_DIR to a directory containing auth.json." >&2
          exit 1
        fi

        BENCH_HOME="$(mktemp -d "${TMPDIR:-/tmp}/librecode-bench-home.XXXXXX")"
        cleanup() {
          rm -rf "$BENCH_HOME"
        }
        trap cleanup EXIT

        cp -a "$AUTH_DIR/." "$BENCH_HOME/"
        if [ -n "${PYTHONPATH:-}" ]; then
          export PYTHONPATH="$(pwd):$PYTHONPATH"
        else
          export PYTHONPATH="$(pwd)"
        fi

        MOUNTS_JSON="$({
          BENCH_HOME="$BENCH_HOME" CONTAINER_HOME="$CONTAINER_HOME" python - <<'PY'
        import json
        import os

        print(json.dumps([{
            "type": "bind",
            "source": os.environ["BENCH_HOME"],
            "target": os.environ["CONTAINER_HOME"],
            "read_only": False,
        }]))
        PY
        })"

        set -- harbor run \
          -d "$DATASET" \
          --agent-import-path "$AGENT_IMPORT_PATH" \
          -k "$K" \
          -n "$N" \
          --jobs-dir "$JOBS_DIR" \
          --mounts-json "$MOUNTS_JSON" \
          --ae "LIBRECODE_HOME=$CONTAINER_HOME"

        if [ -n "$JOB_NAME" ]; then
          set -- "$@" --job-name "$JOB_NAME"
        fi
        if [ "$DEBUG" = "true" ]; then
          set -- "$@" --debug
        fi
        if [ -n "$N_TASKS" ]; then
          set -- "$@" --n-tasks "$N_TASKS"
        fi
        if [ -n "$EXCLUDE_TASKS" ]; then
          for task in $EXCLUDE_TASKS; do
            set -- "$@" --exclude-task-name "$(qualify_task_filter "$task")"
          done
        fi
        if [ -n "$INCLUDE_TASKS" ]; then
          for task in $INCLUDE_TASKS; do
            set -- "$@" --include-task-name "$(qualify_task_filter "$task")"
          done
        fi
        if [ -n "$SHARD_INDEX" ] || [ -n "$SHARD_TOTAL" ]; then
          if [ -z "$SHARD_INDEX" ] || [ -z "$SHARD_TOTAL" ]; then
            echo "Set both LIBRECODE_BENCH_SHARD_INDEX and LIBRECODE_BENCH_SHARD_TOTAL, or neither." >&2
            exit 1
          fi
          if [ "$SHARD_TOTAL" -le 0 ]; then
            echo "LIBRECODE_BENCH_SHARD_TOTAL must be greater than zero." >&2
            exit 1
          fi
          if [ "$SHARD_INDEX" -lt 0 ] || [ "$SHARD_INDEX" -ge "$SHARD_TOTAL" ]; then
            echo "LIBRECODE_BENCH_SHARD_INDEX must be in [0, LIBRECODE_BENCH_SHARD_TOTAL)." >&2
            exit 1
          fi

          TASK_LIST="$(mktemp "${TMPDIR:-/tmp}/librecode-bench-tasks.XXXXXX")"
          if [ -n "$TASK_LIST_FILE" ]; then
            if [ ! -r "$TASK_LIST_FILE" ]; then
              echo "LIBRECODE_BENCH_TASK_LIST_FILE is unreadable: $TASK_LIST_FILE" >&2
              exit 1
            fi
            echo "Using benchmark task list from $TASK_LIST_FILE for shard $SHARD_INDEX/$SHARD_TOTAL..."
            sed '/^[[:space:]]*$/d; /^[[:space:]]*#/d' "$TASK_LIST_FILE" | sort > "$TASK_LIST"
          else
            DATASET_DIR="$(mktemp -d "${TMPDIR:-/tmp}/librecode-bench-dataset.XXXXXX")"
            cleanup_dataset() {
              rm -rf "$DATASET_DIR"
            }
            trap 'cleanup; cleanup_dataset' EXIT

            echo "Downloading dataset index for shard $SHARD_INDEX/$SHARD_TOTAL..."
            harbor dataset download "$DATASET" --output-dir "$DATASET_DIR" --export >/dev/null
            find "$DATASET_DIR" -mindepth 2 -maxdepth 2 -type d -printf '%f\n' | sort > "$TASK_LIST"
          fi
          SHARD_TASKS="$(awk -v shard="$SHARD_INDEX" -v total="$SHARD_TOTAL" '((NR - 1) % total) == shard { print }' "$TASK_LIST")"
          if [ -z "$SHARD_TASKS" ]; then
            echo "No tasks selected for shard $SHARD_INDEX/$SHARD_TOTAL."
            exit 0
          fi
          echo "Selected $(printf '%s\n' "$SHARD_TASKS" | sed '/^$/d' | wc -l | tr -d ' ') tasks for shard $SHARD_INDEX/$SHARD_TOTAL:"
          printf '%s\n' "$SHARD_TASKS" | sed 's/^/  - /'
          while IFS= read -r task; do
            [ -n "$task" ] || continue
            set -- "$@" --include-task-name "$(qualify_task_filter "$task")"
          done <<EOF
        $SHARD_TASKS
        EOF
        fi

        echo "Running benchmark: dataset=$DATASET attempts=$K concurrency=$N jobs_dir=$JOBS_DIR"
        if [ "$LOG_WATCH" = "true" ]; then
          "$@" &
          harbor_pid=$!
          while kill -0 "$harbor_pid" 2>/dev/null; do
            sleep "$LOG_WATCH_INTERVAL"
            echo "--- latest Harbor trial logs ($(date -u +%Y-%m-%dT%H:%M:%SZ)) ---"
            find "$JOBS_DIR" -path '*/trial.log' -type f -printf '%T@ %p\n' 2>/dev/null \
              | sort -rn \
              | head -5 \
              | cut -d' ' -f2- \
              | while IFS= read -r log; do
                  echo "### $log"
                  tail -n 40 "$log" || true
                done
          done
          wait "$harbor_pid"
        else
          "$@"
        fi