feat: Add multi-translator support with DeepL backend

.github/workflows/test.yaml

@@ -7,15 +7,59 @@ on:
     branches: [ main ]
 
 jobs:
-  build:
+  test:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go-version: ['1.21', '1.22', '1.23', '1.24', '1.25']
+
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
       - name: Set up Go
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v5
         with:
-          go-version: 1.25
+          go-version: ${{ matrix.go-version }}
+          cache: true
+
+      - name: Verify gofmt
+        run: test -z "$(gofmt -l .)"
+
+      - name: Vet
+        run: go vet ./...
+
+      - name: Tidy check
+        if: matrix.go-version == '1.25'
+        run: |
+          go mod tidy
+          git diff --exit-code
+
+      - name: Build
+        run: go build -v ./...
 
       - name: Test
-        run: go test -v -run TestTranslator
+        run: go test -v ./...
+
+      - name: Race
+        if: matrix.go-version == '1.25'
+        run: go test -race ./...
+
+      - name: Govulncheck
+        if: matrix.go-version == '1.25'
+        run: |
+          go install golang.org/x/vuln/cmd/govulncheck@latest
+          govulncheck ./...
+
+  benchmark:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.23'
+          cache: true
+
+      - name: Run Benchmarks
+        run: go test -bench=BenchmarkNew -benchmem ./...

CLAUDE.md

@@ -0,0 +1,90 @@
+# CLAUDE.md
+
+## Project
+
+Go library for translation API wrapper supporting multiple backends (Google Translate, DeepL). Module: `gopkg.gilang.dev/translator/v2`
+
+## Commands
+
+```bash
+go test -v ./...           # Run tests
+go test -bench=. ./...     # Run benchmarks
+go mod tidy                # Tidy dependencies
+```
+
+## Structure
+
+- `translate.go` - Public API with multi-translator support
+- `googletranslate/` - Google Translate client (concurrency-safe)
+- `deepl/` - DeepL client (concurrency-safe)
+- `params/` - Parameter structs and language definitions
+- `example/` - Usage examples
+
+## API
+
+### Package-level functions (use default translator)
+
+```go
+gt.Translate(ctx, text, toLanguage)                           // Auto-detect source
+gt.TranslateWithParam(ctx, params.Translate{Text, From, To})  // Struct-based
+gt.ManualTranslate(ctx, text, fromLanguage, toLanguage)       // Explicit languages
+```
+
+### Switch default translator
+
+```go
+gt.UseGoogle()                                    // Use Google (default)
+gt.UseDeepL()                                     // Use DeepL
+gt.UseGoogle(googletranslate.WithHost("..."))    // With options
+gt.UseDeepL(deepl.WithDLSession("..."))          // With options
+```
+
+### Use specific translator
+
+```go
+google := gt.NewGoogleTranslator(opts...)
+deepl := gt.NewDeepLTranslator(opts...)
+gt.TranslateWith(ctx, google, text, toLanguage)
+```
+
+### Google Translate client
+
+```go
+import "gopkg.gilang.dev/translator/v2/googletranslate"
+
+client := googletranslate.New(
+    googletranslate.WithHost("google.co.id"),
+    googletranslate.WithHTTPClient(&http.Client{Timeout: 30*time.Second}),
+    googletranslate.WithProxyURL("http://proxy:8080"),
+)
+client.Translate(ctx, text, from, to)
+
+// Runtime configuration (concurrency-safe)
+client.SetHost("google.com")
+client.SetProxyURL("http://proxy:8080")
+```
+
+### DeepL client
+
+```go
+import "gopkg.gilang.dev/translator/v2/deepl"
+
+client := deepl.New(
+    deepl.WithProxyURL("http://proxy:8080"),
+    deepl.WithDLSession("session-token"),  // For Pro features
+)
+client.Translate(ctx, text, from, to)
+
+// Runtime configuration (concurrency-safe)
+client.SetProxyURL("http://proxy:8080")
+client.SetDLSession("new-session")
+```
+
+## Conventions
+
+- Package imported as `gt`
+- Language codes: ISO 639-1 (e.g., "en", "fr", "id")
+- Use `"auto"` for automatic language detection
+- All functions require `context.Context` as first parameter
+- Both clients are concurrency-safe with mutex protection
+- DeepL may rate limit requests; handle errors appropriately