opencode-test-writer.yml

name: opencode-test-writer

# Required repository secrets:
# - OPENCODE_PAT: Classic PAT with `repo` scope OR fine-grained PAT with:
#     Contents: Read & Write, Pull requests: Read & Write, Metadata: Read
#   Without `repo` scope, git push will fail with 403 permission denied.
# - MINIMAX_API_KEY: API key for the MiniMax M2.7 model

on:
  schedule:
    - cron: '0 4 * * *'
    - cron: '0 12 * * *'
    - cron: '0 20 * * *'
  workflow_dispatch:
    inputs:
      module:
        description: 'Module to write tests for (e.g. graphics/vulkan-device, world/meshing)'
        required: false
        type: string

jobs:
  write-tests:
    runs-on: ubuntu-latest
    timeout-minutes: 60
    permissions:
      id-token: write
      contents: write
      pull-requests: write

    steps:
      - name: Select module to test
        id: select-module
        env:
          INPUT_MODULE: ${{ inputs.module }}
        run: |
          GRAPHICS_MODULES=(
            "graphics/vulkan-device"
            "graphics/vulkan-resources"
            "graphics/vulkan-pipelines"
            "graphics/vulkan-swapchain"
            "graphics/vulkan-frame"
            "graphics/rhi-types"
            "graphics/shadows"
            "graphics/post-process"
          )

          OTHER_MODULES=(
            "engine/core"
            "engine/math"
            "engine/input"
            "world"
            "world/meshing"
            "world/worldgen"
            "engine/ecs"
            "game"
          )

          if [ -n "$INPUT_MODULE" ]; then
            if ! echo "$INPUT_MODULE" | grep -qE '^[a-zA-Z0-9_/-]+$'; then
              echo "ERROR: Invalid module input: '$INPUT_MODULE'" >&2
              exit 1
            fi
            SELECTED="$INPUT_MODULE"
            echo "Manual dispatch: writing tests for ${SELECTED}"
          else
            GRAPHICS_COUNT=${#GRAPHICS_MODULES[@]}
            OTHER_COUNT=${#OTHER_MODULES[@]}

            SLOT=$(($(date +%s) / 28800))
            PARITY=$((SLOT % 2))

            if [ "$PARITY" -eq 0 ]; then
              INDEX=$((SLOT % GRAPHICS_COUNT))
              SELECTED="${GRAPHICS_MODULES[${INDEX}]}"
              echo "Graphics slot: parity=${PARITY} index=${INDEX} -> ${SELECTED}"
            else
              INDEX=$((SLOT % OTHER_COUNT))
              SELECTED="${OTHER_MODULES[${INDEX}]}"
              echo "Other slot: parity=${PARITY} index=${INDEX} -> ${SELECTED}"
            fi
          fi

          BRANCH_NAME="test/$(echo "${SELECTED}" | tr '/' '-')"

          case "$SELECTED" in
            graphics/vulkan-device)
              SCAN_PATHS="src/engine/graphics/vulkan_device.zig src/engine/graphics/vulkan/device.zig src/engine/graphics/vulkan/rhi_state_control.zig"
              ;;
            graphics/vulkan-resources)
              SCAN_PATHS="src/engine/graphics/vulkan/resource_manager.zig src/engine/graphics/vulkan/resource_texture_ops.zig src/engine/graphics/vulkan/rhi_resource_lifecycle.zig src/engine/graphics/vulkan/rhi_resource_setup.zig"
              ;;
            graphics/vulkan-pipelines)
              SCAN_PATHS="src/engine/graphics/vulkan/pipeline_manager.zig src/engine/graphics/vulkan/pipeline_specialized.zig src/engine/graphics/vulkan/shader_registry.zig src/engine/graphics/vulkan/descriptor_manager.zig src/engine/graphics/vulkan/descriptor_bindings.zig"
              ;;
            graphics/vulkan-swapchain)
              SCAN_PATHS="src/engine/graphics/vulkan/swapchain.zig src/engine/graphics/vulkan/swapchain_presenter.zig src/engine/graphics/vulkan_swapchain.zig"
              ;;
            graphics/vulkan-frame)
              SCAN_PATHS="src/engine/graphics/vulkan/frame_manager.zig src/engine/graphics/vulkan/rhi_frame_orchestration.zig src/engine/graphics/vulkan/render_pass_manager.zig src/engine/graphics/vulkan/rhi_pass_orchestration.zig"
              ;;
            graphics/rhi-types)
              SCAN_PATHS="src/engine/graphics/rhi.zig src/engine/graphics/rhi_types.zig src/engine/graphics/rhi_vulkan.zig src/engine/graphics/rhi_tests.zig"
              ;;
            graphics/shadows)
              SCAN_PATHS="src/engine/graphics/shadow_system.zig src/engine/graphics/csm.zig src/engine/graphics/vulkan/shadow_system.zig src/engine/graphics/vulkan/rhi_shadow_bridge.zig src/engine/graphics/shadow_scene.zig"
              ;;
            graphics/post-process)
              SCAN_PATHS="src/engine/graphics/vulkan/bloom_system.zig src/engine/graphics/vulkan/fxaa_system.zig src/engine/graphics/vulkan/taa_system.zig src/engine/graphics/vulkan/ssao_system.zig src/engine/graphics/vulkan/post_process_system.zig"
              ;;
            engine/core)
              SCAN_PATHS="src/engine/core/job_system.zig src/engine/core/ring_buffer.zig src/engine/core/time.zig src/engine/core/log.zig src/engine/core/window.zig"
              ;;
            engine/math)
              SCAN_PATHS="src/engine/math/vec3.zig src/engine/math/mat4.zig src/engine/math/frustum.zig src/engine/math/utils.zig"
              ;;
            engine/input)
              SCAN_PATHS="src/engine/input/input.zig src/engine/input/interfaces.zig"
              ;;
            world)
              SCAN_PATHS="src/world/chunk.zig src/world/block.zig src/world/block_registry.zig src/world/chunk_storage.zig src/world/chunk_allocator.zig src/world/chunk_mesh.zig"
              ;;
            world/meshing)
              SCAN_PATHS="src/world/meshing/greedy_mesher.zig src/world/meshing/ao_calculator.zig src/world/meshing/lighting_sampler.zig src/world/meshing/biome_color_sampler.zig src/world/meshing/boundary.zig"
              ;;
            world/worldgen)
              SCAN_PATHS="src/world/worldgen/overworld_generator.zig src/world/worldgen/biome.zig src/world/worldgen/caves.zig src/world/worldgen/terrain_shape_generator.zig src/world/worldgen/coastal_generator.zig src/world/worldgen/noise_sampler.zig src/world/worldgen/height_sampler.zig src/world/worldgen/surface_builder.zig"
              ;;
            engine/ecs)
              SCAN_PATHS="src/engine/ecs/storage.zig src/engine/ecs/manager.zig src/engine/ecs/entity.zig src/engine/ecs/components.zig"
              ;;
            game)
              SCAN_PATHS="src/game/player.zig src/game/screen.zig src/game/inventory.zig src/game/settings/ src/game/input_mapper.zig src/game/session.zig"
              ;;
            *)
              SCAN_PATHS="src/${SELECTED}"
              ;;
          esac

          {
            echo "module=${SELECTED}"
            echo "branch=${BRANCH_NAME}"
            echo "base_branch=${{ github.event.repository.default_branch }}"
            echo "scan_paths=${SCAN_PATHS}"
          } >> "$GITHUB_OUTPUT"

      # OPENCODE_PAT must be a classic PAT with `repo` scope (full control of private repositories)
      # or a fine-grained PAT with Contents: Read & Write on this repository.
      # Without write permission, git push will fail with 403.
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          ref: ${{ steps.select-module.outputs.base_branch }}
          fetch-depth: 0
          token: ${{ secrets.OPENCODE_PAT }}

      - name: Configure git identity
        run: |
          git config user.name "opencode[bot]"
          git config user.email "opencode[bot]@users.noreply.github.com"

      - name: Ensure test label exists
        run: |
          if ! gh label list --json name --jq '.[].name' | grep -q '^automated-test$'; then
            gh label create "automated-test" \
              --description "Test PRs created by automated opencode test writer" \
              --color "0E8A16"
          fi
        env:
          GH_TOKEN: ${{ secrets.OPENCODE_PAT }}

      - name: Check for existing automated test PRs
        id: check-existing
        env:
          INPUT_MODULE: ${{ inputs.module }}
          GH_TOKEN: ${{ secrets.OPENCODE_PAT }}
        run: |
          EXISTING=$(gh pr list \
            --base ${{ steps.select-module.outputs.base_branch }} \
            --state open \
            --limit 50 \
            --json number,headRefName,labels \
            --jq '.[] | select((.headRefName | startswith("opencode/schedule-")) or ((.labels | map(.name)) | index("automated-test"))) | "#\(.number) (\(.headRefName))"' || true)
          if [ -n "$EXISTING" ] && [ -z "$INPUT_MODULE" ]; then
            echo "skip=true" >> "$GITHUB_OUTPUT"
            echo "Existing automated test PRs already open:"
            printf '%s\n' "$EXISTING"
          else
            echo "skip=false" >> "$GITHUB_OUTPUT"
          fi

      - name: Validate scan paths exist
        if: steps.check-existing.outputs.skip != 'true'
        run: |
          MISSING=0
          for path in ${{ steps.select-module.outputs.scan_paths }}; do
            if [ ! -e "$path" ]; then
              echo "WARNING: scan path does not exist: $path"
              MISSING=$((MISSING + 1))
            fi
          done
          if [ "$MISSING" -gt 0 ]; then
            echo "::warning::$MISSING scan path(s) missing — the scan_paths case statement in this workflow may need updating"
          fi

      - name: Verify PAT push permissions
        if: steps.check-existing.outputs.skip != 'true'
        run: |
          if ! git push --dry-run origin HEAD:${{ steps.select-module.outputs.base_branch }} 2>/dev/null; then
            echo "::error::OPENCODE_PAT cannot push to repository. Ensure the PAT has 'repo' scope (classic) or Contents: Read & Write (fine-grained)."
            exit 1
          fi
          echo "PAT has push permissions."

      - name: Setup Nix
        if: steps.check-existing.outputs.skip != 'true'
        uses: ./.github/actions/setup-nix

      # XDG_CACHE_HOME=/tmp — non-persistent but avoids permission issues (see opencode-audit.yml)
      - name: Run opencode test writer
        if: steps.check-existing.outputs.skip != 'true'
        uses: anomalyco/opencode/github@latest
        env:
          GITHUB_TOKEN: ${{ secrets.OPENCODE_PAT }}
          GH_TOKEN: ${{ secrets.OPENCODE_PAT }}
          MINIMAX_API_KEY: ${{ secrets.MINIMAX_API_KEY }}
          XDG_CACHE_HOME: /tmp/opencode-cache
        with:
          model: minimax-coding-plan/MiniMax-M2.7
          use_github_token: true
          prompt: |
            Load the `test-writer` skill first — it contains the full codebase context, testing patterns, and workflow rules.

            ## YOUR TASK

            Write 3-8 high-quality unit tests for the module `${{ steps.select-module.outputs.module }}`, targeting `${{ github.event.repository.default_branch }}`.

            ## FILES TO SCAN

            Read these source files to find untested code:
            ${{ steps.select-module.outputs.scan_paths }}

            Also read any existing test files in the same directories (look for `*_tests.zig` patterns).

            ## GIT WORKFLOW — CRITICAL

            You are running inside the opencode GitHub Action. The infrastructure auto-creates a branch and will handle `git push` and PR creation after you finish.

            **STAY ON THE CURRENT BRANCH. Do NOT create a new branch. Do NOT run `git checkout -b`. Do NOT push. Do NOT run `gh pr create`. The infrastructure does all of that for you.**

            1. Write your test files
            2. Register new test files in `src/tests.zig`
            3. Format: `nix develop --command zig fmt src/`
            4. Run tests: `nix develop --command zig build test` — ALL tests must pass
            5. Commit your changes: `git add` and `git commit` with message `test: add {area} tests for ${{ steps.select-module.outputs.module }}`
            6. STOP. Do not push or create a PR.

      - name: Find and label created PR
        if: steps.check-existing.outputs.skip != 'true'
        run: |
          MAX_RETRIES=8
          HEAD_SHA=$(git rev-parse HEAD)
          PR_NUM=""
          for i in $(seq 1 "$MAX_RETRIES"); do
            sleep $((i * 3))
            echo "Attempt $i/$MAX_RETRIES: searching for PR for commit ${HEAD_SHA}..."
            PR_NUM=$(gh api \
              "repos/${{ github.repository }}/commits/${HEAD_SHA}/pulls" \
              --jq '[.[] | select(.state == "open")] | .[0].number // empty' 2>/dev/null || true)
            if [ -n "$PR_NUM" ]; then
              break
            fi
          done
          if [ -n "$PR_NUM" ]; then
            echo "Found newly created PR #$PR_NUM for commit ${HEAD_SHA}"
            if ! gh pr edit "$PR_NUM" --add-label "automated-test" 2>/dev/null; then
              echo "::warning::Failed to add automated-test label to PR #$PR_NUM"
            fi
          else
            echo "::warning::No open PR found for commit ${HEAD_SHA} after $MAX_RETRIES attempts"
          fi
        env:
          GH_TOKEN: ${{ secrets.OPENCODE_PAT }}