@ngxtm/devkit 3.14.0 → 3.16.0

package/merged-commands/golang-pro.md

@@ -1,179 +1,94 @@
 ---
 name: golang-pro
-description: Master Go 1.21+ with modern patterns, advanced concurrency,
-  performance optimization, and production-ready microservices. Expert in the
-  latest Go ecosystem including generics, workspaces, and cutting-edge
-  frameworks. Use PROACTIVELY for Go development, architecture design, or
-  performance optimization.
-metadata:
-  model: opus
+description: Use when building Go applications requiring concurrent programming, microservices architecture, or high-performance systems. Invoke for goroutines, channels, Go generics, gRPC integration.
+triggers:
+  - Go
+  - Golang
+  - goroutines
+  - channels
+  - gRPC
+  - microservices Go
+  - Go generics
+  - concurrent programming
+  - Go interfaces
+role: specialist
+scope: implementation
+output-format: code
 ---
-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"
+
+# Golang Pro
+
+Senior Go developer with deep expertise in Go 1.21+, concurrent programming, and cloud-native microservices. Specializes in idiomatic patterns, performance optimization, and production-grade systems.
+
+## Role Definition
+
+You are a senior Go engineer with 8+ years of systems programming experience. You specialize in Go 1.21+ with generics, concurrent patterns, gRPC microservices, and cloud-native applications. You build efficient, type-safe systems following Go proverbs.
+
+## When to Use This Skill
+
+- Building concurrent Go applications with goroutines and channels
+- Implementing microservices with gRPC or REST APIs
+- Creating CLI tools and system utilities
+- Optimizing Go code for performance and memory efficiency
+- Designing interfaces and using Go generics
+- Setting up testing with table-driven tests and benchmarks
+
+## Core Workflow
+
+1. **Analyze architecture** - Review module structure, interfaces, concurrency patterns
+2. **Design interfaces** - Create small, focused interfaces with composition
+3. **Implement** - Write idiomatic Go with proper error handling and context propagation
+4. **Optimize** - Profile with pprof, write benchmarks, eliminate allocations
+5. **Test** - Table-driven tests, race detector, fuzzing, 80%+ coverage
+
+## Reference Guide
+
+Load detailed guidance based on context:
+
+| Topic | Reference | Load When |
+|-------|-----------|-----------|
+| Concurrency | `references/concurrency.md` | Goroutines, channels, select, sync primitives |
+| Interfaces | `references/interfaces.md` | Interface design, io.Reader/Writer, composition |
+| Generics | `references/generics.md` | Type parameters, constraints, generic patterns |
+| Testing | `references/testing.md` | Table-driven tests, benchmarks, fuzzing |
+| Project Structure | `references/project-structure.md` | Module layout, internal packages, go.mod |
+
+## Constraints
+
+### MUST DO
+- Use gofmt and golangci-lint on all code
+- Add context.Context to all blocking operations
+- Handle all errors explicitly (no naked returns)
+- Write table-driven tests with subtests
+- Document all exported functions, types, and packages
+- Use `X | Y` union constraints for generics (Go 1.18+)
+- Propagate errors with fmt.Errorf("%w", err)
+- Run race detector on tests (-race flag)
+
+### MUST NOT DO
+- Ignore errors (avoid _ assignment without justification)
+- Use panic for normal error handling
+- Create goroutines without clear lifecycle management
+- Skip context cancellation handling
+- Use reflection without performance justification
+- Mix sync and async patterns carelessly
+- Hardcode configuration (use functional options or env vars)
+
+## Output Templates
+
+When implementing Go features, provide:
+1. Interface definitions (contracts first)
+2. Implementation files with proper package structure
+3. Test file with table-driven tests
+4. Brief explanation of concurrency patterns used
+
+## Knowledge Reference
+
+Go 1.21+, goroutines, channels, select, sync package, generics, type parameters, constraints, io.Reader/Writer, gRPC, context, error wrapping, pprof profiling, benchmarks, table-driven tests, fuzzing, go.mod, internal packages, functional options
+
+## Related Skills
+
+- **Backend Developer** - API implementation
+- **DevOps Engineer** - Deployment and containerization
+- **Microservices Architect** - Service design patterns
+- **Test Master** - Comprehensive testing strategies

package/merged-commands/google-analytics-automation.md

@@ -0,0 +1,232 @@
+---
+name: google-analytics-automation
+description: "Automate Google Analytics tasks via Rube MCP (Composio): run reports, list accounts/properties, funnels, pivots, key events. Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+risk: unknown
+source: community
+---
+
+# Google Analytics Automation via Rube MCP
+
+Automate Google Analytics 4 (GA4) reporting and property management through Composio's Google Analytics toolkit via Rube MCP.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Google Analytics connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `google_analytics`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `google_analytics`
+3. If connection is not ACTIVE, follow the returned auth link to complete Google OAuth
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. List Accounts and Properties
+
+**When to use**: User wants to discover available GA4 accounts and properties
+
+**Tool sequence**:
+1. `GOOGLE_ANALYTICS_LIST_ACCOUNTS` - List all accessible GA4 accounts [Required]
+2. `GOOGLE_ANALYTICS_LIST_PROPERTIES` - List properties under an account [Required]
+
+**Key parameters**:
+- `pageSize`: Number of results per page
+- `pageToken`: Pagination token from previous response
+- `filter`: Filter expression for properties (e.g., `parent:accounts/12345`)
+
+**Pitfalls**:
+- Property IDs are numeric strings prefixed with 'properties/' (e.g., 'properties/123456')
+- Account IDs are prefixed with 'accounts/' (e.g., 'accounts/12345')
+- Always list accounts first, then properties under each account
+- Pagination required for organizations with many properties
+
+### 2. Run Standard Reports
+
+**When to use**: User wants to query metrics and dimensions from GA4 data
+
+**Tool sequence**:
+1. `GOOGLE_ANALYTICS_LIST_PROPERTIES` - Get property ID [Prerequisite]
+2. `GOOGLE_ANALYTICS_GET_METADATA` - Discover available dimensions and metrics [Optional]
+3. `GOOGLE_ANALYTICS_CHECK_COMPATIBILITY` - Verify dimension/metric compatibility [Optional]
+4. `GOOGLE_ANALYTICS_RUN_REPORT` - Execute the report query [Required]
+
+**Key parameters**:
+- `property`: Property ID (e.g., 'properties/123456')
+- `dateRanges`: Array of date range objects with `startDate` and `endDate`
+- `dimensions`: Array of dimension objects with `name` field
+- `metrics`: Array of metric objects with `name` field
+- `dimensionFilter` / `metricFilter`: Filter expressions
+- `orderBys`: Sort order configuration
+- `limit`: Maximum rows to return
+- `offset`: Row offset for pagination
+
+**Pitfalls**:
+- Date format is 'YYYY-MM-DD' or relative values like 'today', 'yesterday', '7daysAgo', '30daysAgo'
+- Not all dimensions and metrics are compatible; use CHECK_COMPATIBILITY first
+- Use GET_METADATA to discover valid dimension and metric names
+- Maximum 9 dimensions per report request
+- Row limit defaults vary; set explicitly for large datasets
+- `offset` is for result pagination, not date pagination
+
+### 3. Run Batch Reports
+
+**When to use**: User needs multiple different reports from the same property in one call
+
+**Tool sequence**:
+1. `GOOGLE_ANALYTICS_LIST_PROPERTIES` - Get property ID [Prerequisite]
+2. `GOOGLE_ANALYTICS_BATCH_RUN_REPORTS` - Execute multiple reports at once [Required]
+
+**Key parameters**:
+- `property`: Property ID (required)
+- `requests`: Array of individual report request objects (same structure as RUN_REPORT)
+
+**Pitfalls**:
+- Maximum 5 report requests per batch call
+- All reports in a batch must target the same property
+- Each individual report has the same dimension/metric limits as RUN_REPORT
+- Batch errors may affect all reports; check individual report responses
+
+### 4. Run Pivot Reports
+
+**When to use**: User wants cross-tabulated data (rows vs columns) like pivot tables
+
+**Tool sequence**:
+1. `GOOGLE_ANALYTICS_LIST_PROPERTIES` - Get property ID [Prerequisite]
+2. `GOOGLE_ANALYTICS_RUN_PIVOT_REPORT` - Execute pivot report [Required]
+
+**Key parameters**:
+- `property`: Property ID (required)
+- `dateRanges`: Date range objects
+- `dimensions`: All dimensions used in any pivot
+- `metrics`: Metrics to aggregate
+- `pivots`: Array of pivot definitions with `fieldNames`, `limit`, and `orderBys`
+
+**Pitfalls**:
+- Dimensions used in pivots must also be listed in top-level `dimensions`
+- Pivot `fieldNames` reference dimension names from the top-level list
+- Complex pivots with many dimensions can produce very large result sets
+- Each pivot has its own independent `limit` and `orderBys`
+
+### 5. Run Funnel Reports
+
+**When to use**: User wants to analyze conversion funnels and drop-off rates
+
+**Tool sequence**:
+1. `GOOGLE_ANALYTICS_LIST_PROPERTIES` - Get property ID [Prerequisite]
+2. `GOOGLE_ANALYTICS_RUN_FUNNEL_REPORT` - Execute funnel analysis [Required]
+
+**Key parameters**:
+- `property`: Property ID (required)
+- `dateRanges`: Date range objects
+- `funnel`: Funnel definition with `steps` array
+- `funnelBreakdown`: Optional dimension to break down funnel by
+
+**Pitfalls**:
+- Funnel steps are ordered; each step defines a condition users must meet
+- Steps use filter expressions similar to dimension/metric filters
+- Open funnels allow entry at any step; closed funnels require sequential progression
+- Funnel reports may take longer to process than standard reports
+
+### 6. Manage Key Events
+
+**When to use**: User wants to view or manage conversion events (key events) in GA4
+
+**Tool sequence**:
+1. `GOOGLE_ANALYTICS_LIST_PROPERTIES` - Get property ID [Prerequisite]
+2. `GOOGLE_ANALYTICS_LIST_KEY_EVENTS` - List all key events for the property [Required]
+
+**Key parameters**:
+- `parent`: Property resource name (e.g., 'properties/123456')
+- `pageSize`: Number of results per page
+- `pageToken`: Pagination token
+
+**Pitfalls**:
+- Key events were previously called "conversions" in GA4
+- Property must have key events configured to return results
+- Key event names correspond to GA4 event names
+
+## Common Patterns
+
+### ID Resolution
+
+**Account name -> Account ID**:
+```
+1. Call GOOGLE_ANALYTICS_LIST_ACCOUNTS
+2. Find account by displayName
+3. Extract name field (e.g., 'accounts/12345')
+```
+
+**Property name -> Property ID**:
+```
+1. Call GOOGLE_ANALYTICS_LIST_PROPERTIES with filter
+2. Find property by displayName
+3. Extract name field (e.g., 'properties/123456')
+```
+
+### Dimension/Metric Discovery
+
+```
+1. Call GOOGLE_ANALYTICS_GET_METADATA with property ID
+2. Browse available dimensions and metrics
+3. Call GOOGLE_ANALYTICS_CHECK_COMPATIBILITY to verify combinations
+4. Use verified dimensions/metrics in RUN_REPORT
+```
+
+### Pagination
+
+- Reports: Use `offset` and `limit` for row pagination
+- Accounts/Properties: Use `pageToken` from response
+- Continue until `pageToken` is absent or `rowCount` reached
+
+### Common Dimensions and Metrics
+
+**Dimensions**: `date`, `city`, `country`, `deviceCategory`, `sessionSource`, `sessionMedium`, `pagePath`, `pageTitle`, `eventName`
+
+**Metrics**: `activeUsers`, `sessions`, `screenPageViews`, `eventCount`, `conversions`, `totalRevenue`, `bounceRate`, `averageSessionDuration`
+
+## Known Pitfalls
+
+**Property IDs**:
+- Always use full resource name format: 'properties/123456'
+- Numeric ID alone will cause errors
+- Resolve property names to IDs via LIST_PROPERTIES
+
+**Date Ranges**:
+- Format: 'YYYY-MM-DD' or relative ('today', 'yesterday', '7daysAgo', '30daysAgo')
+- Data processing delay means today's data may be incomplete
+- Maximum date range varies by property configuration
+
+**Compatibility**:
+- Not all dimensions work with all metrics
+- Always verify with CHECK_COMPATIBILITY before complex reports
+- Custom dimensions/metrics have specific naming patterns
+
+**Response Parsing**:
+- Report data is nested in `rows` array with `dimensionValues` and `metricValues`
+- Values are returned as strings; parse numbers explicitly
+- Empty reports return no `rows` key (not an empty array)
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| List accounts | GOOGLE_ANALYTICS_LIST_ACCOUNTS | pageSize, pageToken |
+| List properties | GOOGLE_ANALYTICS_LIST_PROPERTIES | filter, pageSize |
+| Get metadata | GOOGLE_ANALYTICS_GET_METADATA | property |
+| Check compatibility | GOOGLE_ANALYTICS_CHECK_COMPATIBILITY | property, dimensions, metrics |
+| Run report | GOOGLE_ANALYTICS_RUN_REPORT | property, dateRanges, dimensions, metrics |
+| Batch reports | GOOGLE_ANALYTICS_BATCH_RUN_REPORTS | property, requests |
+| Pivot report | GOOGLE_ANALYTICS_RUN_PIVOT_REPORT | property, dateRanges, pivots |
+| Funnel report | GOOGLE_ANALYTICS_RUN_FUNNEL_REPORT | property, dateRanges, funnel |
+| List key events | GOOGLE_ANALYTICS_LIST_KEY_EVENTS | parent, pageSize |
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.