@hybridlabor-api/bdb-antigravity-skills 1.0.0

package/skills/global_legacy/go-playwright/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: go-playwright
+description: "Expert capability for robust, stealthy, and efficient browser automation using Playwright Go."
+risk: safe
+source: "https://github.com/playwright-community/playwright-go"
+date_added: "2026-02-27"
+---
+
+# Playwright Go Automation Expert
+
+## Overview
+This skill provides a comprehensive framework for writing high-performance, production-grade browser automation scripts using `github.com/playwright-community/playwright-go`. It enforces architectural best practices (contexts over instances), robust error handling, structured logging (Zap), and advanced human-emulation techniques to bypass anti-bot systems.
+
+## When to Use This Skill
+- Use when the user asks to "scrape," "automate," or "test" a website using Go.
+- Use when the target site has complex dynamic content (SPA, React, Vue) requiring a real browser.
+- Use when the user mentions "stealth," "avoiding detection," "cloudflare," or "human-like" behavior.
+- Use when debugging existing Playwright scripts.
+
+## Safety & Risk
+**Risk Level: 🔵 Safe**
+
+- **Sandboxed Execution:** Browser contexts are isolated; they do not persist data to the host machine unless explicitly saved.
+- **Resource Management:** Designed to close browsers and contexts via `defer` to prevent memory leaks.
+- **No External State-Change:** Default behavior is read-only (scraping/testing) unless the script is explicitly designed to submit forms or modify data.
+
+## Limitations
+- **Environment Dependencies:** Requires Playwright drivers and browsers to be installed (`go run github.com/playwright-community/playwright-go/cmd/playwright@latest install --with-deps`).
+- **Resource Intensity:** Launching full browser instances (even headless) consumes significant RAM/CPU. Use single-browser/multi-context architecture.
+- **Bot Detection:** While this skill includes stealth techniques, extremely strict anti-bot systems (e.g., rigorous Cloudflare settings) may still detect automation.
+- **CAPTCHAs:** Does not include built-in CAPTCHA solving capabilities.
+
+## Strategic Implementation Guidelines
+
+### 1. Architecture: Contexts vs. Browsers
+**CRITICAL:** Never launch a new `Browser` instance for every task.
+- **Pattern:** Launch the `Browser` *once* (singleton). Create a new `BrowserContext` for each distinct session or task.
+- **Why:** Contexts are lightweight and created in milliseconds. Browsers take seconds to launch.
+- **Isolation:** Contexts provide complete isolation (cookies, cache, storage) without the overhead of a new process.
+
+### 2. Logging & Observability
+- **Library:** Use `go.uber.org/zap` exclusively.
+- **Rule:** Do not use `fmt.Println`.
+- **Modes:**
+  - **Dev:** `zap.NewDevelopment()` (Console friendly)
+  - **Prod:** `zap.NewProduction()` (JSON structured)
+- **Traceability:** Log every navigation, click, and input with context fields (e.g., `logger.Info("clicking button", zap.String("selector", sel))`).
+
+### 3. Error Handling & Stability
+- **Graceful Shutdown:** Always use `defer` to close Pages, Contexts, and Browsers.
+- **Panic Recovery:** Wrap critical automation routines in a safe runner that recovers panics and logs the stack trace.
+- **Timeouts:** Never rely on default timeouts. Set explicit timeouts (e.g., `playwright.PageClickOptions{Timeout: playwright.Float(5000)}`).
+
+### 4. Stealth & Human-Like Behavior
+To bypass anti-bot systems (Cloudflare, Akamai), the generated code must **imitate human physiology**:
+- **Non-Linear Mouse Movement:** Never teleport the mouse. Implement a helper that moves the mouse along a Bezier curve with random jitter.
+- **Input Latency:** never use `Fill()`. Use `Type()` with random delays between keystrokes (50ms–200ms).
+- **Viewport Randomization:** Randomize the viewport size slightly (e.g., 1920x1080 ± 15px) to avoid fingerprinting.
+- **Behavioral Noise:** Randomly scroll, focus/unfocus the window, or hover over irrelevant elements ("idling") during long waits.
+- **User-Agent:** Rotate User-Agents for every new Context.
+
+### 5. Documentation Usage
+- **Primary Source:** Rely on your internal knowledge of the API first to save tokens.
+- **Fallback:** Refer to the official docs [playwright-go documentation](https://pkg.go.dev/github.com/playwright-community/playwright-go#section-documentation) ONLY if:
+  - You encounter an unknown error.
+  - You need to implement complex network interception or authentication flows.
+  - The API has changed significantly.
+
+## Resources
+- `resources/implementation-playbook.md` for detailed code examples and implementation patterns.
+
+### Summary Checklist for Agent
+ - Is Debug Mode on? -> `Headless=false`, `SlowMo=100+`.
+ - Is it a new user identity? -> `NewContext`, apply new Proxy, rotate `User-Agent`.
+ - Is the action critical? -> Wrap in `SafeAction` with Zap logging.
+ - Is the target guarded (Cloudflare/Akamai)? -> Enable `HumanType`, `BezierMouse`, and Stealth Scripts.

package/skills/global_legacy/go-playwright/resources/implementation-playbook.md

@@ -0,0 +1,110 @@
+# Playwright Go Automation - Implementation Playbook
+
+## Code Examples
+
+### Standard Initialization (Headless + Zap)
+```go
+package main
+
+import (
+    "log"
+
+    "github.com/playwright-community/playwright-go"
+    "go.uber.org/zap"
+)
+
+func main() {
+    // 1. Setup Logger
+    logger, _ := zap.NewDevelopment()
+    defer logger.Sync()
+
+    // 2. Start Playwright Driver
+    pw, err := playwright.Run()
+    if err != nil {
+        logger.Fatal("could not start playwright", zap.Error(err))
+    }
+    
+    // 3. Launch Browser (Singleton)
+    // Use Headless: false and SlowMo for Debugging
+    browser, err := pw.Chromium.Launch(playwright.BrowserTypeLaunchOptions{
+        Headless: playwright.Bool(false), 
+        SlowMo:   playwright.Float(100), // Slow actions by 100ms for visibility
+    })
+    if err != nil {
+        logger.Fatal("could not launch browser", zap.Error(err))
+    }
+    defer browser.Close() // Graceful cleanup
+
+    // 4. Create Isolated Context (Session)
+    context, err := browser.NewContext(playwright.BrowserNewContextOptions{
+        UserAgent: playwright.String("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"),
+        Viewport: &playwright.Size{Width: 1920, Height: 1080},
+    })
+    if err != nil {
+        logger.Fatal("could not create context", zap.Error(err))
+    }
+    defer context.Close()
+
+    // 5. Open Page
+    page, _ := context.NewPage()
+    
+    // ... Implementation ...
+    // Example: page.Goto("https://example.com")
+}
+```
+
+### Human-Like Typing & Interaction
+```go
+import (
+    "math/rand"
+    "time"
+)
+
+// HumanType simulates a user typing with variable speed
+func HumanType(locator playwright.Locator, text string) {
+    // Focus the element first (like a human)
+    locator.Click()
+    
+    for _, char := range text {
+        // Random delay: 50ms to 150ms
+        delay := time.Duration(rand.Intn(100) + 50) * time.Millisecond
+        time.Sleep(delay)
+        locator.Press(string(char))
+    }
+}
+
+// HumanClick adds offset and hesitation
+func HumanClick(page playwright.Page, selector string) {
+    box, _ := page.Locator(selector).BoundingBox()
+    if box == nil {
+        return
+    }
+    
+    // Calculate center with random offset (jitter)
+    // Note: This is an example logic. 
+    x := box.X + box.Width/2 + (rand.Float64()*10 - 5)
+    y := box.Y + box.Height/2 + (rand.Float64()*10 - 5)
+    
+    // Move mouse smoothly. 
+    // Ideally, implement a Bezier curve function for 'steps' to look truly human.
+    page.Mouse().Move(x, y, playwright.MouseMoveOptions{Steps: playwright.Int(10)})
+    time.Sleep(100 * time.Millisecond) // Hesitate
+    page.Mouse().Click(x, y)
+}
+```
+
+### Session Management (Save/Load Cookies)
+
+```go
+func SaveSession(context playwright.BrowserContext, filepath string) {
+    // cookies, _ := context.Cookies()
+    // Serialize cookies to JSON and write to 'filepath'
+    // Implementation left to user: json.Marshal(cookies) -> os.WriteFile
+}
+
+func LoadSession(context playwright.BrowserContext, filepath string) {
+    // Read JSON from 'filepath' and deserialize
+    // var cookies []playwright.Cookie
+    // context.AddCookies(cookies)
+}
+```

package/skills/global_legacy/golang-pro/SKILL.md

@@ -0,0 +1,181 @@
+---
+name: golang-pro
+description: Master Go 1.21+ with modern patterns, advanced concurrency, performance optimization, and production-ready microservices.
+risk: unknown
+source: community
+date_added: '2026-02-27'
+---
+You are a Go expert specializing in modern Go 1.21+ development with advanced concurrency patterns, performance optimization, and production-ready system design.
+
+## Use this skill when
+
+- Building Go services, CLIs, or microservices
+- Designing concurrency patterns and performance optimizations
+- Reviewing Go architecture and production readiness
+
+## Do not use this skill when
+
+- You need another language or runtime
+- You only need basic Go syntax explanations
+- You cannot change Go tooling or build configuration
+
+## Instructions
+
+1. Confirm Go version, tooling, and runtime constraints.
+2. Choose concurrency and architecture patterns.
+3. Implement with testing and profiling.
+4. Optimize for latency, memory, and reliability.
+
+## Purpose
+Expert Go developer mastering Go 1.21+ features, modern development practices, and building scalable, high-performance applications. Deep knowledge of concurrent programming, microservices architecture, and the modern Go ecosystem.
+
+## Capabilities
+
+### Modern Go Language Features
+- Go 1.21+ features including improved type inference and compiler optimizations
+- Generics (type parameters) for type-safe, reusable code
+- Go workspaces for multi-module development
+- Context package for cancellation and timeouts
+- Embed directive for embedding files into binaries
+- New error handling patterns and error wrapping
+- Advanced reflection and runtime optimizations
+- Memory management and garbage collector understanding
+
+### Concurrency & Parallelism Mastery
+- Goroutine lifecycle management and best practices
+- Channel patterns: fan-in, fan-out, worker pools, pipeline patterns
+- Select statements and non-blocking channel operations
+- Context cancellation and graceful shutdown patterns
+- Sync package: mutexes, wait groups, condition variables
+- Memory model understanding and race condition prevention
+- Lock-free programming and atomic operations
+- Error handling in concurrent systems
+
+### Performance & Optimization
+- CPU and memory profiling with pprof and go tool trace
+- Benchmark-driven optimization and performance analysis
+- Memory leak detection and prevention
+- Garbage collection optimization and tuning
+- CPU-bound vs I/O-bound workload optimization
+- Caching strategies and memory pooling
+- Network optimization and connection pooling
+- Database performance optimization
+
+### Modern Go Architecture Patterns
+- Clean architecture and hexagonal architecture in Go
+- Domain-driven design with Go idioms
+- Microservices patterns and service mesh integration
+- Event-driven architecture with message queues
+- CQRS and event sourcing patterns
+- Dependency injection and wire framework
+- Interface segregation and composition patterns
+- Plugin architectures and extensible systems
+
+### Web Services & APIs
+- HTTP server optimization with net/http and fiber/gin frameworks
+- RESTful API design and implementation
+- gRPC services with protocol buffers
+- GraphQL APIs with gqlgen
+- WebSocket real-time communication
+- Middleware patterns and request handling
+- Authentication and authorization (JWT, OAuth2)
+- Rate limiting and circuit breaker patterns
+
+### Database & Persistence
+- SQL database integration with database/sql and GORM
+- NoSQL database clients (MongoDB, Redis, DynamoDB)
+- Database connection pooling and optimization
+- Transaction management and ACID compliance
+- Database migration strategies
+- Connection lifecycle management
+- Query optimization and prepared statements
+- Database testing patterns and mock implementations
+
+### Testing & Quality Assurance
+- Comprehensive testing with testing package and testify
+- Table-driven tests and test generation
+- Benchmark tests and performance regression detection
+- Integration testing with test containers
+- Mock generation with mockery and gomock
+- Property-based testing with gopter
+- End-to-end testing strategies
+- Code coverage analysis and reporting
+
+### DevOps & Production Deployment
+- Docker containerization with multi-stage builds
+- Kubernetes deployment and service discovery
+- Cloud-native patterns (health checks, metrics, logging)
+- Observability with OpenTelemetry and Prometheus
+- Structured logging with slog (Go 1.21+)
+- Configuration management and feature flags
+- CI/CD pipelines with Go modules
+- Production monitoring and alerting
+
+### Modern Go Tooling
+- Go modules and version management
+- Go workspaces for multi-module projects
+- Static analysis with golangci-lint and staticcheck
+- Code generation with go generate and stringer
+- Dependency injection with wire
+- Modern IDE integration and debugging
+- Air for hot reloading during development
+- Task automation with Makefile and just
+
+### Security & Best Practices
+- Secure coding practices and vulnerability prevention
+- Cryptography and TLS implementation
+- Input validation and sanitization
+- SQL injection and other attack prevention
+- Secret management and credential handling
+- Security scanning and static analysis
+- Compliance and audit trail implementation
+- Rate limiting and DDoS protection
+
+## Behavioral Traits
+- Follows Go idioms and effective Go principles consistently
+- Emphasizes simplicity and readability over cleverness
+- Uses interfaces for abstraction and composition over inheritance
+- Implements explicit error handling without panic/recover
+- Writes comprehensive tests including table-driven tests
+- Optimizes for maintainability and team collaboration
+- Leverages Go's standard library extensively
+- Documents code with clear, concise comments
+- Focuses on concurrent safety and race condition prevention
+- Emphasizes performance measurement before optimization
+
+## Knowledge Base
+- Go 1.21+ language features and compiler improvements
+- Modern Go ecosystem and popular libraries
+- Concurrency patterns and best practices
+- Microservices architecture and cloud-native patterns
+- Performance optimization and profiling techniques
+- Container orchestration and Kubernetes patterns
+- Modern testing strategies and quality assurance
+- Security best practices and compliance requirements
+- DevOps practices and CI/CD integration
+- Database design and optimization patterns
+
+## Response Approach
+1. **Analyze requirements** for Go-specific solutions and patterns
+2. **Design concurrent systems** with proper synchronization
+3. **Implement clean interfaces** and composition-based architecture
+4. **Include comprehensive error handling** with context and wrapping
+5. **Write extensive tests** with table-driven and benchmark tests
+6. **Consider performance implications** and suggest optimizations
+7. **Document deployment strategies** for production environments
+8. **Recommend modern tooling** and development practices
+
+## Example Interactions
+- "Design a high-performance worker pool with graceful shutdown"
+- "Implement a gRPC service with proper error handling and middleware"
+- "Optimize this Go application for better memory usage and throughput"
+- "Create a microservice with observability and health check endpoints"
+- "Design a concurrent data processing pipeline with backpressure handling"
+- "Implement a Redis-backed cache with connection pooling"
+- "Set up a modern Go project with proper testing and CI/CD"
+- "Debug and fix race conditions in this concurrent Go code"
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

package/skills/global_legacy/google-sheets-automation/SKILL.md

@@ -0,0 +1,149 @@
+---
+name: google-sheets-automation
+description: "Lightweight Google Sheets integration with standalone OAuth authentication. No MCP server required. Full read/write access."
+risk: critical
+source: community
+license: Apache-2.0
+metadata:
+  author: sanjay3290
+  version: "1.0"
+---
+
+# Google Sheets
+
+Lightweight Google Sheets integration with standalone OAuth authentication. No MCP server required. Full read/write access.
+
+> **Requires Google Workspace account.** Personal Gmail accounts are not supported.
+
+## First-Time Setup
+
+Authenticate with Google (opens browser):
+```bash
+python scripts/auth.py login
+```
+
+Check authentication status:
+```bash
+python scripts/auth.py status
+```
+
+Logout when needed:
+```bash
+python scripts/auth.py logout
+```
+
+## Read Commands
+
+All operations via `scripts/sheets.py`. Auto-authenticates on first use if not logged in.
+
+```bash
+# Get spreadsheet content as plain text (default)
+python scripts/sheets.py get-text SPREADSHEET_ID
+
+# Get spreadsheet content as CSV
+python scripts/sheets.py get-text SPREADSHEET_ID --format csv
+
+# Get spreadsheet content as JSON
+python scripts/sheets.py get-text SPREADSHEET_ID --format json
+
+# Get values from a specific range (A1 notation)
+python scripts/sheets.py get-range SPREADSHEET_ID "Sheet1!A1:D10"
+python scripts/sheets.py get-range SPREADSHEET_ID "A1:C5"
+
+# Find spreadsheets by search query
+python scripts/sheets.py find "budget 2024"
+python scripts/sheets.py find "sales report" --limit 5
+
+# Get spreadsheet metadata (sheets, dimensions, etc.)
+python scripts/sheets.py get-metadata SPREADSHEET_ID
+```
+
+## Write Commands
+
+```bash
+# Update a range of cells with values (JSON 2D array)
+python scripts/sheets.py update-range SPREADSHEET_ID "Sheet1!A1:B2" '[["Hello","World"],["Foo","Bar"]]'
+
+# Update with RAW input (no formula parsing, treats everything as literal text)
+python scripts/sheets.py update-range SPREADSHEET_ID "Sheet1!A1:B1" '[["=SUM(A1:A5)","text"]]' --raw
+
+# Append rows after the last data row
+python scripts/sheets.py append-rows SPREADSHEET_ID "Sheet1!A:Z" '[["New Row Col A","New Row Col B"]]'
+
+# Clear values from a range (keeps formatting)
+python scripts/sheets.py clear-range SPREADSHEET_ID "Sheet1!A1:B10"
+
+# Batch update (advanced - for formatting, merging, etc.)
+python scripts/sheets.py batch-update SPREADSHEET_ID '[{"updateCells":{"range":{"sheetId":0},"fields":"userEnteredValue"}}]'
+```
+
+## Spreadsheet ID
+
+You can use either:
+- The spreadsheet ID: `1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms`
+- The full URL: `https://docs.google.com/spreadsheets/d/1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms/edit`
+
+The script automatically extracts the ID from URLs.
+
+## Output Formats
+
+### Text (default)
+Human-readable format with pipe separators:
+```
+Spreadsheet Title: Sales Data
+Sheet Name: Q1
+Name | Revenue | Units
+Product A | 10000 | 50
+Product B | 15000 | 75
+```
+
+### CSV
+Standard CSV format, suitable for further processing:
+```
+Name,Revenue,Units
+Product A,10000,50
+Product B,15000,75
+```
+
+### JSON
+Structured data format:
+```json
+{
+  "Q1": [
+    ["Name", "Revenue", "Units"],
+    ["Product A", "10000", "50"]
+  ]
+}
+```
+
+## A1 Notation Examples
+
+- `Sheet1!A1:B10` - Range A1 to B10 on Sheet1
+- `Sheet1!A:A` - All of column A on Sheet1
+- `Sheet1!1:1` - All of row 1 on Sheet1
+- `A1:C5` - Range on the first sheet
+
+## Value Input Options
+
+- **USER_ENTERED** (default): Values are parsed as if typed by a user. Numbers, dates, and formulas are interpreted.
+- **RAW** (`--raw` flag): Values are stored exactly as provided. No parsing of formulas or number formatting.
+
+## Token Management
+
+Tokens stored securely using the system keyring:
+- **macOS**: Keychain
+- **Windows**: Windows Credential Locker
+- **Linux**: Secret Service API (GNOME Keyring, KDE Wallet, etc.)
+
+Service name: `google-sheets-skill-oauth`
+
+Tokens automatically refresh when expired using Google's cloud function.
+
+
+## When to Use
+Use this skill when tackling tasks related to its primary domain or functionality as described above.
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.