Taskfile.yml

# https://taskfile.dev

version: '3'

includes:
  wails:
    taskfile: ./Taskfile.wails.yml
    flatten: true
  windows-cli:
    taskfile: ./Taskfile.windows.yml
  linux-cli:
    taskfile: ./Taskfile.linux.yml
  docker:
    taskfile: ./Taskfile.docker.yml

vars:
  VERSION: ""
  BUILD_DIR: build
  DIST_DIR: build/dist
  PORT: 12580
  BIN_NAME: "tingly-box"
  BIN_DIR: "bin"

  # Submodule versions (format: "name:branch/tag/commit")
  # Example: "openai-go:tingly-dev-v3.32.0"
  OPENAI_GO_VERSION: "tingly-dev-v3.37.0"
  ANTHROPIC_SDK_GO_VERSION: "tingly-dev-v1.45.0"
  GO_GENAI_VERSION: "upstream-v1.58.0"

tasks:
  build:
    aliases:
      - cli:build
    cmds:
      - task: web:dist
      - task: go:build
  dev:
    aliases:
      - cli:dev
    cmds:
      - task: web:dist
      - task: start

  e2e:
    cmds:
      - go build ./... && go test -v ./internal/protocol/transform -run TestE2E
  
  start:
    aliases:
      - http
    cmds:
      - go run ./cli/tingly-box --verbose start --debug --port 12580 --browser=false
 
  restart:
    cmds:
      - go run ./cli/tingly-box --verbose restart --debug --port 12580 --browser=false
 
  record:
    cmds:
      - go run ./cli/tingly-box --verbose start --port 12580 --record-mode=scenario --debug --browser=false

  swagger:
    aliases:
      - openapi
    cmds:
      - |
        # Generate OpenAPI v3 schema directly without starting the server
        go run ./cli/tingly-box swagger

  codegen:
    cmds:
      - |
        cd frontend
        pnpm install
        pnpm gen:api

  go:build:
    env:
      ARCH:
      OS:
    cmds:
      - |
        # Get build info
        VERSION="dev"
        GIT_COMMIT="$(git rev-parse HEAD 2>/dev/null || echo 'unknown')"
        BUILD_TIME="$(date -u '+%Y-%m-%d-%H-%M-%S' 2>/dev/null || echo 'unknown')"
        GO_VERSION="$(go env GOVERSION 2>/dev/null || echo 'unknown')"
        PLATFORM="${OS}/${ARCH}"

        # Determine binary extension based on OS
        BINARY_EXT=""
        if [ "{{.OS}}" = "windows" ]; then
          BINARY_EXT=".exe"
        fi

        # Set CGO_ENABLED: 1 for all platform
        CGO_ENABLED=1


        # Build with ldflags
        mkdir -p build
        LDFLAGS="-X main.version=${VERSION} -X main.gitCommit=${GIT_COMMIT} -X main.buildTime=${BUILD_TIME} -X main.goVersion=${GO_VERSION} -X main.platform=${PLATFORM}"
        GOOS={{.OS}} GOARCH={{.ARCH}} go build -ldflags="${LDFLAGS}" -o ./build/{{.BIN_NAME}} ./cli/tingly-box
        CGO_ENABLED=${CGO_ENABLED} GOOS={{.OS}} GOARCH={{.ARCH}} go build -ldflags="${LDFLAGS}" -o ./build/{{.BIN_NAME}}${BINARY_EXT} ./cli/tingly-box

  go:test:
    cmds:
      - |
        go test ./internal/...

  tests:interface:
    summary: Run Python interface tests (test_automation)
    cmds:
      - |
        python -m tests.test_automation

  mcp:web-tools:
    summary: Run local MCP stdio server exposing mcp_web_search/mcp_web_fetch tools
    cmds:
      - |
        python3 ./scripts/mcp_web_tools.py

  web:
    aliases:
      - web:dev
    cmds:
      - |
        echo "This is only for frontend dev, please start your tingly-box server too"
      - |
        cd frontend;
        pnpm install
      - |
        cd frontend;
        pnpm dev

  web:mock:
    cmds:
      - |
        echo "This is only for frontend dev, please start your tingly-box server too"
      - |
        cd frontend;
        pnpm install
      - |
        cd frontend;
        pnpm dev:mock

  web:build:
    aliases:
      - web:dist
    cmds:
      - task: codegen
      - |
        cd frontend;
        if [ "$CI" = "true" ]; then
          pnpm install --no-frozen-lockfile;
        else
          pnpm install;
        fi;
        pnpm build
      - |
        mkdir -p internal/web/dist/
        cp -R frontend/dist/* internal/web/dist/

  web:build:dev:
    cmds:
      - task: codegen
      - |
        cd frontend;
        if [ "$CI" = "true" ]; then
          pnpm install --no-frozen-lockfile;
        else
          pnpm install;
        fi;
        pnpm build:dev
      - |
        mkdir -p internal/web/dist/
        cp -R frontend/dist/* internal/web/dist/

  check:zig:
    summary: Check if zig is installed
    cmds:
      - |
        if ! command -v zig &> /dev/null; then
          echo "Error: zig not found!"
          echo ""
          echo "To install zig:"
          echo "  macOS:   brew install zig"
          echo "  Or download from: https://ziglang.org/download/"
          echo ""
          exit 1
        fi
        echo "Found: $(zig version)"

  # remote-coder Service tasks
  remote-coder:run:
    summary: Run remote-coder service via tingly-box rc
    env:
      RCC_PORT: "18080"
      RCC_SESSION_TIMEOUT: "30m"
    cmds:
      - |
        go run ./cli/tingly-box rc

  remote-coder:test:
    summary: Run tests for remote-coder service
    cmds:
      - |
        go test ./internal/remote_coder/... -v

  remote-coder-token:build:
    summary: Build the remote-coder-token binary
    cmds:
      - |
        # Determine binary extension based on OS
        BINARY_EXT=""
        if [ "$(go env GOOS)" = "windows" ]; then
          BINARY_EXT=".exe"
        fi
        go build -o ./bin/remote-coder-token${BINARY_EXT} ./cmd/remote-coder

  remote-coder-token:run:
    summary: Generate an API token (run via SSH)
    cmds:
      - go run ./cmd/remote-coder

  submodule:
    summary: Show git HEAD and branch for each submodule in libs/
    cmds:
      - |
        for dir in libs/*/; do
          if [ -d "$dir" ]; then
            name=$(basename "$dir")
            cd "$dir"
            head=$(git rev-parse HEAD 2>/dev/null || echo "N/A")
            branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "N/A")
            echo "$name:"
            echo "  HEAD: $head"
            echo "  Branch: $branch"
            echo ""
            cd - > /dev/null
          fi
        done

  submodule:sync:
    summary: Sync and update all submodules to their remote branches
    cmds:
      - |
        git submodule sync
        git submodule update --remote
      - |
        for dir in libs/*/; do
          if [ -d "$dir" ]; then
            name=$(basename "$dir")
            cd "$dir"
            git --no-pager log -n 3
            cd - > /dev/null
          fi
        done

  submodule:update:
    summary: Update submodules to versions specified in Taskfile.yml variables
    cmds:
      - |
        echo "Updating openai-go to {{.OPENAI_GO_VERSION}}..."
        cd libs/openai-go
        git fetch origin
        git checkout {{.OPENAI_GO_VERSION}}
        cd - > /dev/null
      - |
        echo "Updating anthropic-sdk-go to {{.ANTHROPIC_SDK_GO_VERSION}}..."
        cd libs/anthropic-sdk-go
        git fetch origin
        git checkout {{.ANTHROPIC_SDK_GO_VERSION}}
        cd - > /dev/null
      - |
        echo "Updating go-genai to {{.GO_GENAI_VERSION}}..."
        cd libs/go-genai
        git fetch origin
        git checkout {{.GO_GENAI_VERSION}}
        cd - > /dev/null
      - |
        echo "Updating .gitmodules with new branch versions..."
        # Update each submodule's branch in .gitmodules
        python3 << 'EOF'
        import re
        with open('.gitmodules', 'r') as f:
            content = f.read()

        # Update openai-go branch
        content = re.sub(
            r'(\[submodule "libs/openai-go"\]\s+path = libs/openai-go\s+url = [^\n]+\s+)branch = "[^"]+"',
            r'\1branch = "{{.OPENAI_GO_VERSION}}"',
            content
        )

        # Update anthropic-sdk-go branch
        content = re.sub(
            r'(\[submodule "libs/anthropic-sdk-go"\]\s+path = libs/anthropic-sdk-go\s+url = [^\n]+\s+)branch = "[^"]+"',
            r'\1branch = "{{.ANTHROPIC_SDK_GO_VERSION}}"',
            content
        )

        # Update go-genai branch
        content = re.sub(
            r'(\[submodule "libs/go-genai"\]\s+path = libs/go-genai\s+url = [^\n]+\s+)branch = "[^"]+"',
            r'\1branch = "{{.GO_GENAI_VERSION}}"',
            content
        )

        with open('.gitmodules', 'w') as f:
            f.write(content)

        print(".gitmodules updated successfully")
        EOF
      - task: submodule

  submodule:openai-go:
    summary: Update openai-go submodule to a specific version (branch/tag/commit)
    cmds:
      - |
        cd libs/openai-go
        git fetch origin
        git checkout {{.CLI_ARGS}}
        cd - > /dev/null
      - |
        echo "openai-go updated to:"
        cd libs/openai-go
        git --no-pager log -n 1
        cd - > /dev/null

  submodule:anthropic-sdk-go:
    summary: Update anthropic-sdk-go submodule to a specific version (branch/tag/commit)
    cmds:
      - |
        cd libs/anthropic-sdk-go
        git fetch origin
        git checkout {{.CLI_ARGS}}
        cd - > /dev/null
      - |
        echo "anthropic-sdk-go updated to:"
        cd libs/anthropic-sdk-go
        git --no-pager log -n 1
        cd - > /dev/null

  submodule:go-genai:
    summary: Update go-genai submodule to a specific version (branch/tag/commit)
    cmds:
      - |
        cd libs/go-genai
        git fetch origin
        git checkout {{.CLI_ARGS}}
        cd - > /dev/null
      - |
        echo "go-genai updated to:"
        cd libs/go-genai
        git --no-pager log -n 1
        cd - > /dev/null
        
  changelog:
    cmds:
      - |
        # Find the latest release tag (excluding alpha, beta, rc, pre, etc. suffixes)
        LATEST_RELEASE_TAG=$(git tag -l "v*[0-9]" | grep -v -e 'alpha' -e 'beta' -e 'rc' -e 'pre' -e 'snapshot' | sort -V | tail -n 1)

        # If no tag is found, use HEAD~10 as default value
        if [ -z "$LATEST_RELEASE_TAG" ]; then
          echo "Warning: No release tag found, showing last 10 commits"
          git --no-pager log -10 --pretty=format:"%h - %s (%an, %ar)" --graph
        else
          echo "Latest release tag: $LATEST_RELEASE_TAG"
          echo ""
          echo "Commits since $LATEST_RELEASE_TAG:"
          git --no-pager log ${LATEST_RELEASE_TAG}..HEAD --pretty=format:"%h - %s (%an, %ar)" --graph
        fi

  harness:matrix:
    cmds:
      - |
        go run ./cli/harness matrix