Taskfile.yml

# Claude Code Go SDK - Build Pipeline (Task)
# https://taskfile.dev
#
# Alternative: Use `make <command>` if you prefer Makefiles (see Makefile)

version: "3"

vars:
  PROJECT_NAME: Claude Code Go SDK
  BIN_DIR: ./bin
  COVERAGE_DIR: ./coverage

tasks:
  default:
    desc: "Run complete build and test pipeline"
    aliases: [all]
    cmds:
      - task: banner
      - task: clean
      - task: deps
      - task: build-all
      - task: test-all
      - task: coverage
      - task: summary

  banner:
    desc: "Display project banner"
    silent: true
    cmds:
      - echo "╔══════════════════════════════════════════════════════════════╗"
      - echo "║                    {{.PROJECT_NAME}}                     ║"
      - echo "║                      Build Pipeline                          ║"
      - echo "╚══════════════════════════════════════════════════════════════╝"
      - echo ""

  clean:
    desc: "Clean build artifacts and test cache"
    cmds:
      - rm -rf {{.BIN_DIR}}
      - rm -rf {{.COVERAGE_DIR}}
      - rm -rf it_works/
      - go clean -cache -testcache
      - mkdir -p {{.BIN_DIR}} {{.COVERAGE_DIR}}

  deps:
    desc: "Download and verify dependencies"
    cmds:
      - echo "📦 Checking dependencies..."
      - go mod download
      - go mod verify
      - go mod tidy
      - echo "✅ Dependencies verified"

  build-all:
    desc: "Build all components"
    cmds:
      - task: build-lib
      - task: build-examples

  build-lib:
    desc: "Build the core library"
    cmds:
      - echo "🔨 Building core library..."
      - go build ./pkg/claude
      - echo "✅ Core library built successfully"

  examples:
    desc: "Build all example programs (alias)"
    aliases: [build-examples]
    cmds:
      - task: build-examples

  build-examples:
    desc: "Build example programs"
    cmds:
      - echo "🔨 Building examples..."
      - mkdir -p {{.BIN_DIR}}
      - go build -o {{.BIN_DIR}}/basic-example ./examples/basic || echo "❌ Basic example build failed"
      - go build -o {{.BIN_DIR}}/advanced-example ./examples/advanced || echo "❌ Advanced example build failed"
      - go build -o {{.BIN_DIR}}/testing-example ./examples/testing || echo "❌ Testing example build failed"
      - task: build-demo-streaming
      - task: build-demo-basic
      - task: build-dangerous-example
      - echo "✅ Example builds completed"

  # Individual example build targets for development
  build-basic:
    desc: "Build basic example only"
    cmds:
      - echo "🔨 Building basic example..."
      - mkdir -p {{.BIN_DIR}}
      - go build -o {{.BIN_DIR}}/basic-example ./examples/basic
      - echo "✅ Basic example built at {{.BIN_DIR}}/basic-example"

  build-advanced:
    desc: "Build advanced example only"
    cmds:
      - echo "🔨 Building advanced example..."
      - mkdir -p {{.BIN_DIR}}
      - go build -o {{.BIN_DIR}}/advanced-example ./examples/advanced
      - echo "✅ Advanced example built at {{.BIN_DIR}}/advanced-example"

  build-testing:
    desc: "Build testing example only"
    cmds:
      - echo "🔨 Building testing example..."
      - mkdir -p {{.BIN_DIR}}
      - go build -o {{.BIN_DIR}}/testing-example ./examples/testing
      - echo "✅ Testing example built at {{.BIN_DIR}}/testing-example"

  build-demo:
    desc: "Build the interactive demo (streaming)"
    deps: [build-demo-streaming]

  build-demo-streaming:
    desc: "Build the streaming demo"
    cmds:
      - echo "🔨 Building streaming demo..."
      - mkdir -p {{.BIN_DIR}}
      - |
        cd examples/demo/streaming
        go mod tidy
        go build -o ../../../{{.BIN_DIR}}/demo ./cmd/demo
      - echo "✅ Streaming demo built successfully"

  build-demo-basic:
    desc: "Build the basic demo"
    cmds:
      - echo "🔨 Building basic demo..."
      - mkdir -p {{.BIN_DIR}}
      - |
        cd examples/demo/basic
        go mod tidy
        go build -o ../../../{{.BIN_DIR}}/demo-basic ./cmd/demo
      - echo "✅ Basic demo built successfully"

  build-dangerous-example:
    desc: "Build dangerous usage example"
    cmds:
      - echo "🔨 Building dangerous example..."
      - mkdir -p {{.BIN_DIR}}
      - |
        cd examples/dangerous_usage
        go mod tidy
        go build -o ../../{{.BIN_DIR}}/dangerous-example .
      - echo "✅ Dangerous example built successfully"

  test-all:
    desc: "Run all tests"
    cmds:
      - task: test-lib

  test-lib:
    desc: "Test the core library"
    cmds:
      - echo "🧪 Testing core library..."
      - go test -v ./pkg/claude || echo "❌ Core library tests failed"
      - echo "✅ Core library tests completed (check for errors above)"

  test-dangerous:
    desc: "Test dangerous package (security-sensitive features)"
    cmds:
      - echo "🚨 Testing dangerous package..."
      - go test -v ./pkg/claude/dangerous || echo "❌ Dangerous package tests failed"
      - echo "✅ Dangerous package tests completed (check for errors above)"

  demo:
    desc: "Run the interactive Claude Code Go SDK demo (streaming)"
    deps: [build-demo-streaming]
    cmds:
      - echo "🚀 Claude Code Go SDK Demo (Streaming)"
      - echo "====================================="
      - |
        # Check Go version
        if ! command -v go &> /dev/null; then
            echo "❌ Error: Go is not installed or not in PATH"
            exit 1
        fi

        go_version=$(go version | awk '{print $3}' | sed 's/go//')
        major_version=$(echo $go_version | cut -d. -f1)
        minor_version=$(echo $go_version | cut -d. -f2)

        if [[ $major_version -lt 1 ]] || [[ $major_version -eq 1 && $minor_version -lt 20 ]]; then
            echo "❌ Error: Go ≥1.20 is required (found: $go_version)"
            exit 1
        fi

        echo "✔️  Go version: $go_version"
      - |
        # Check for claude CLI
        if ! claude_path=$(command -v claude 2>/dev/null); then
            echo "❌ Error: claude CLI not found in PATH"
            echo "   Please install from: https://docs.anthropic.com/en/docs/claude-code/getting-started"
            exit 1
        fi

        echo "✔️  Found claude CLI: $claude_path"
      - echo ""
      - echo "🎯 Starting streaming demo with real-time tool display..."
      - echo "   Type your responses and press Enter"
      - echo "   Type 'exit', 'quit', 'bye', or press Enter on empty line to exit"
      - echo ""
      - "{{.BIN_DIR}}/demo"

  demo-streaming:
    desc: "Run the streaming demo"
    deps: [build-demo-streaming]
    cmds:
      - task: demo

  demo-basic:
    desc: "Run the basic demo"
    deps: [build-demo-basic]
    cmds:
      - echo "🚀 Claude Code Go SDK Demo (Basic)"
      - echo "================================"
      - |
        # Check Go version
        if ! command -v go &> /dev/null; then
            echo "❌ Error: Go is not installed or not in PATH"
            exit 1
        fi

        go_version=$(go version | awk '{print $3}' | sed 's/go//')
        major_version=$(echo $go_version | cut -d. -f1)
        minor_version=$(echo $go_version | cut -d. -f2)

        if [[ $major_version -lt 1 ]] || [[ $major_version -eq 1 && $minor_version -lt 20 ]]; then
            echo "❌ Error: Go ≥1.20 is required (found: $go_version)"
            exit 1
        fi

        echo "✔️  Go version: $go_version"
      - |
        # Check for claude CLI
        if ! claude_path=$(command -v claude 2>/dev/null); then
            echo "❌ Error: claude CLI not found in PATH"
            echo "   Please install from: https://docs.anthropic.com/en/docs/claude-code/getting-started"
            exit 1
        fi

        echo "✔️  Found claude CLI: $claude_path"
      - echo ""
      - echo "🎯 Starting basic demo with simple JSON output..."
      - echo "   Type your responses and press Enter"
      - echo "   Type 'exit', 'quit', 'bye', or press Enter on empty line to exit"
      - echo ""
      - "{{.BIN_DIR}}/demo-basic"

  run-dangerous:
    desc: "Run dangerous features example (development only)"
    deps: [build-dangerous-example]
    cmds:
      - echo "🚨 Running Dangerous Features Example"
      - echo "====================================="
      - |
        # Check required environment variables
        if [ "$CLAUDE_ENABLE_DANGEROUS" != "i-accept-all-risks" ]; then
            echo "❌ Error: CLAUDE_ENABLE_DANGEROUS must be set to 'i-accept-all-risks'"
            echo "   export CLAUDE_ENABLE_DANGEROUS=\"i-accept-all-risks\""
            exit 1
        fi

        # Check not in production
        if [ "$NODE_ENV" = "production" ] || [ "$GO_ENV" = "production" ] || [ "$ENVIRONMENT" = "production" ]; then
            echo "❌ Error: Cannot run dangerous example in production environment"
            exit 1
        fi

        echo "✔️  Security requirements met"
      - echo ""
      - "{{.BIN_DIR}}/dangerous-example"

  coverage:
    desc: "Generate test coverage report"
    cmds:
      - echo "📊 Generating coverage report..."
      - mkdir -p {{.COVERAGE_DIR}}
      - go test -coverprofile={{.COVERAGE_DIR}}/coverage.out ./pkg/... || echo "❌ Coverage generation failed"
      - go tool cover -func={{.COVERAGE_DIR}}/coverage.out || echo "❌ Coverage summary failed"
      - go tool cover -html={{.COVERAGE_DIR}}/coverage.out -o {{.COVERAGE_DIR}}/coverage.html || echo "❌ HTML coverage report failed"
      - echo "✅ Coverage generation completed"
      - echo "📄 View HTML report at {{.COVERAGE_DIR}}/coverage.html"

  summary:
    desc: "Display final summary"
    silent: true
    cmds:
      - echo ""
      - echo "╔══════════════════════════════════════════════════════════════╗"
      - echo "║                        PIPELINE SUMMARY                     ║"
      - echo "╚══════════════════════════════════════════════════════════════╝"
      - echo ""
      - echo "🎉 Build and test pipeline completed!"
      - echo ""
      - echo "📁 SDK Library:"
      - echo "   • pkg/claude/ - Go SDK ready for import"
      - echo ""
      - echo "📁 Example Binaries:"
      - echo "   • {{.BIN_DIR}}/basic-example - Basic usage examples"
      - echo "   • {{.BIN_DIR}}/advanced-example - Advanced MCP examples"
      - echo "   • {{.BIN_DIR}}/testing-example - Testing utilities"
      - echo ""
      - echo "📊 Reports:"
      - echo "   • Coverage at {{.COVERAGE_DIR}}/coverage.html"
      - echo ""
      - echo "🚀 Usage:"
      - echo "   • import \"github.com/lancekrogers/claude-code-go/pkg/claude\""
      - echo "   • See examples/ for usage patterns"
      - echo ""

  test:
    desc: "Run tests with verbose output"
    cmds:
      - go test -v ./...

  test-coverage:
    desc: "Run tests with coverage and open HTML report"
    cmds:
      - mkdir -p {{.COVERAGE_DIR}}
      - go test -coverprofile={{.COVERAGE_DIR}}/coverage.out ./pkg/...
      - go tool cover -html={{.COVERAGE_DIR}}/coverage.out -o {{.COVERAGE_DIR}}/coverage.html
      - echo "Coverage report at {{.COVERAGE_DIR}}/coverage.html"

  lint:
    desc: "Run linting tools"
    cmds:
      - go fmt ./...
      - go vet ./...

  fix:
    desc: "Fix common issues"
    cmds:
      - go fmt ./...
      - go mod tidy
      - echo "✅ Common issues fixed"

  docs:
    desc: "Generate and serve documentation"
    cmds:
      - echo "📚 Starting documentation server..."
      - echo "Visit http://localhost:6060/pkg/github.com/lancekrogers/claude-code-go/"
      - godoc -http=:6060

  # Integration Testing Tasks
  test-integration:
    desc: "🧪 Run integration tests with mock server"
    cmds:
      - task: start-mock-server-bg
      - sleep 2
      - INTEGRATION_TESTS=1 USE_MOCK_SERVER=1 go test -tags=integration ./test/integration -v
      - task: stop-mock-server

  test-integration-real:
    desc: "🧪 Run integration tests with real Claude Code CLI"
    cmds:
      - echo "⚠️  This will use real Claude Code CLI and may consume credits"
      - echo "Claude will handle authentication automatically if needed"
      - INTEGRATION_TESTS=1 go test -tags=integration ./test/integration -v

  # Mock Server Tasks
  start-mock-server:
    desc: "🚀 Start mock Claude server"
    cmds:
      - echo "🚀 Starting mock Claude server on port 8080..."
      - go run test/mockserver/main.go

  start-mock-server-bg:
    desc: "🚀 Start mock Claude server in background"
    cmds:
      - echo "🚀 Starting mock Claude server in background..."
      - go run test/mockserver/main.go &
      - echo $! > /tmp/mock-server.pid

  stop-mock-server:
    desc: "🛑 Stop mock Claude server"
    cmds:
      - |
        if [ -f /tmp/mock-server.pid ]; then
          kill $(cat /tmp/mock-server.pid) 2>/dev/null || true
          rm -f /tmp/mock-server.pid
          echo "🛑 Mock server stopped"
        fi

  test-mock-server:
    desc: "🧪 Test mock server functionality"
    cmds:
      - echo "🧪 Testing mock server..."
      - curl -X POST http://localhost:8080/claude -d '-p "Hello world"' -s
      - echo ""
      - curl -X POST http://localhost:8080/claude -d '-p "Hello" --output-format json' -s | jq .
      - echo "✅ Mock server tests completed"

  # Benchmark and Performance Testing
  test-bench:
    desc: "📊 Run benchmark tests"
    cmds:
      - echo "📊 Running benchmark tests..."
      - go test -bench=. ./pkg/claude -benchmem
      - echo "✅ Benchmark tests completed"

  test-race:
    desc: "🏃 Run tests with race detection"
    cmds:
      - echo "🏃 Running tests with race detection..."
      - go test -race ./...
      - echo "✅ Race detection tests completed"

  test-memory:
    desc: "🧠 Run memory profiling tests"
    cmds:
      - echo "🧠 Running memory profiling tests..."
      - go test -memprofile=mem.prof ./pkg/claude
      - go tool pprof mem.prof
      - echo "✅ Memory profiling completed"

  # Local Development Testing
  test-local:
    desc: "🏠 Run local development tests"
    cmds:
      - echo "🏠 Running local development test suite..."
      - task: test
      - task: test-integration
      - echo "✅ All local tests completed"

  # Comprehensive Testing
  test-full:
    desc: "🎯 Run comprehensive test suite"
    cmds:
      - echo "🎯 Running comprehensive test suite..."
      - task: test
      - task: test-race
      - task: test-integration
      - task: test-bench
      - echo "✅ Comprehensive testing completed"

  # Setup Testing Environment
  setup-test-env:
    desc: "⚙️ Setup testing environment"
    cmds:
      - echo "⚙️ Setting up testing environment..."
      - |
        echo "export CLAUDE_CODE_PATH=claude" >> .env.test
        echo "export TEST_TIMEOUT=30s" >> .env.test
        echo "export MOCK_SERVER_PORT=8080" >> .env.test
        echo "export USE_MOCK_SERVER=1" >> .env.test
        echo "# Set USE_MOCK_SERVER=0 to use real Claude CLI" >> .env.test
      - echo "✅ Test environment setup complete"
      - echo "📝 Edit .env.test to configure your testing environment"
      - echo "💡 Claude Code CLI will handle authentication automatically when needed"