@mytechtoday/augment-extensions 1.4.0 → 1.5.0

package/augment-extensions/coding-standards/go/templates/prompts/cloud-native.md

@@ -0,0 +1,121 @@
+# Cloud-Native Go Application AI Template
+
+## Context
+
+You are building a cloud-native Go application designed to run in Kubernetes or other container orchestration platforms.
+
+## Key Requirements
+
+### Kubernetes Integration
+- Use `k8s.io/client-go` for Kubernetes API interactions
+- Implement informers and listers for efficient resource watching
+- Handle API errors using `k8s.io/apimachinery/pkg/api/errors`
+- Use controller-runtime for custom controllers
+- Implement leader election for high availability
+
+### Configuration Management
+- Load configuration from environment variables
+- Support multiple configuration sources (env, files, config maps)
+- Never hardcode secrets - use environment variables or secret managers
+- Validate all configuration on startup
+- Support hot reloading for non-critical configuration
+
+### Health Checks
+- Implement separate `/health` (liveness) and `/ready` (readiness) endpoints
+- Keep health checks lightweight (<1s response time)
+- Include dependency checks in readiness probes
+- Return detailed status information with component-level details
+- Implement graceful degradation for non-critical dependencies
+
+### Graceful Shutdown
+- Handle SIGTERM and SIGINT signals
+- Implement graceful shutdown with timeout (typically 30s)
+- Stop accepting new requests first
+- Complete in-flight requests
+- Close database connections and other resources
+- Log shutdown progress
+
+## Code Structure
+
+```go
+type Application struct {
+    config  *Config
+    db      *sql.DB
+    server  *http.Server
+    checker *HealthChecker
+}
+
+func NewApplication(cfg *Config) (*Application, error) {
+    // Initialize dependencies
+    // Set up health checks
+    // Return configured application
+}
+
+func (app *Application) Start() error {
+    // Start HTTP server
+    // Start background workers
+}
+
+func (app *Application) Shutdown(ctx context.Context) error {
+    // Graceful shutdown logic
+}
+```
+
+## Example Patterns
+
+### Environment Configuration
+```go
+type Config struct {
+    Port        int    `envconfig:"PORT" default:"8080"`
+    DatabaseURL string `envconfig:"DATABASE_URL" required:"true"`
+    LogLevel    string `envconfig:"LOG_LEVEL" default:"info"`
+}
+```
+
+### Health Check Handler
+```go
+func (app *Application) readinessHandler(w http.ResponseWriter, r *http.Request) {
+    ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
+    defer cancel()
+    
+    components, err := app.checker.Check(ctx)
+    // Return structured JSON response
+}
+```
+
+### Graceful Shutdown
+```go
+quit := make(chan os.Signal, 1)
+signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+<-quit
+
+ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+defer cancel()
+
+if err := app.Shutdown(ctx); err != nil {
+    log.Fatalf("Shutdown failed: %v", err)
+}
+```
+
+## Best Practices
+
+1. **12-Factor App Principles**: Follow the twelve-factor app methodology
+2. **Stateless Design**: Keep application stateless for horizontal scaling
+3. **Observability**: Include structured logging, metrics, and tracing
+4. **Resource Limits**: Set appropriate CPU and memory limits
+5. **Security**: Run as non-root user, use read-only filesystems where possible
+
+## Common Pitfalls to Avoid
+
+- ❌ Hardcoding configuration values
+- ❌ Not implementing health checks
+- ❌ Ignoring shutdown signals
+- ❌ Blocking operations in health checks
+- ❌ Not validating configuration on startup
+
+## References
+
+- [Kubernetes Best Practices](https://kubernetes.io/docs/concepts/configuration/overview/)
+- [The Twelve-Factor App](https://12factor.net/)
+- [Go Cloud Development Kit](https://gocloud.dev/)
+

package/augment-extensions/coding-standards/go/templates/prompts/devops.md

@@ -0,0 +1,146 @@
+# DevOps Tooling Go Application AI Template
+
+## Context
+
+You are building a DevOps automation tool in Go for deployment, infrastructure management, and CI/CD integration.
+
+## Key Requirements
+
+### CLI Framework
+- Use Cobra for command-line interface with subcommands
+- Implement proper flag parsing and validation
+- Provide clear help text and usage examples
+- Support configuration via environment variables and config files
+
+### Automation Principles
+- Implement idempotent operations (safe to retry)
+- Provide detailed progress feedback for long-running operations
+- Support dry-run mode for all destructive operations
+- Implement rollback capability for failed deployments
+- Log all operations with appropriate detail levels
+
+### CI/CD Integration
+- Return appropriate exit codes for pipeline integration
+- Support environment-based configuration
+- Generate machine-readable output (JSON, JUnit XML)
+- Publish artifacts with checksums and metadata
+- Implement health checks for deployment verification
+
+### Infrastructure as Code
+- Use declarative configuration (YAML/JSON)
+- Implement state management for tracking resources
+- Resolve resource dependencies correctly
+- Detect configuration drift
+- Support plan and apply workflow
+
+## Code Structure
+
+```go
+type DeploymentConfig struct {
+    Name        string
+    Environment string
+    Version     string
+}
+
+type DeploymentOptions struct {
+    DryRun  bool
+    Verbose bool
+    Timeout time.Duration
+}
+
+func Deploy(ctx context.Context, config *DeploymentConfig, opts *DeploymentOptions) error {
+    // Deployment logic with progress feedback
+}
+```
+
+## Example Patterns
+
+### Cobra CLI
+```go
+var rootCmd = &cobra.Command{
+    Use:   "devops-tool",
+    Short: "A DevOps automation tool",
+}
+
+var deployCmd = &cobra.Command{
+    Use:   "deploy [environment]",
+    Short: "Deploy application",
+    Args:  cobra.ExactArgs(1),
+    RunE: func(cmd *cobra.Command, args []string) error {
+        return deployToEnvironment(args[0])
+    },
+}
+
+func init() {
+    deployCmd.Flags().StringP("version", "v", "latest", "Version to deploy")
+    deployCmd.Flags().BoolP("dry-run", "d", false, "Perform dry run")
+    rootCmd.AddCommand(deployCmd)
+}
+```
+
+### Idempotent Operations
+```go
+func EnsureDeployment(ctx context.Context, config *DeploymentConfig) error {
+    existing, err := getDeployment(ctx, config.Name)
+    if err != nil && !isNotFoundError(err) {
+        return err
+    }
+    
+    if existing != nil {
+        if deploymentMatches(existing, config) {
+            log.Printf("Deployment already up to date")
+            return nil
+        }
+        return updateDeployment(ctx, config)
+    }
+    
+    return createDeployment(ctx, config)
+}
+```
+
+### Dry-Run Mode
+```go
+func Deploy(ctx context.Context, config *DeploymentConfig, opts *DeploymentOptions) error {
+    steps := []DeploymentStep{
+        {Name: "Validate", Fn: validateConfig},
+        {Name: "Build", Fn: buildImage},
+        {Name: "Deploy", Fn: updateDeployment},
+    }
+    
+    for _, step := range steps {
+        if opts.DryRun {
+            log.Printf("[DRY RUN] Would execute: %s", step.Name)
+            continue
+        }
+        
+        if err := step.Fn(ctx, config); err != nil {
+            return err
+        }
+    }
+    
+    return nil
+}
+```
+
+## Best Practices
+
+1. **User Experience**: Provide clear, actionable error messages
+2. **Safety**: Always confirm destructive operations
+3. **Observability**: Log all operations with timestamps
+4. **Resilience**: Implement retries with exponential backoff
+5. **Documentation**: Include examples in help text
+
+## Common Pitfalls to Avoid
+
+- ❌ Not implementing dry-run mode
+- ❌ Missing rollback capability
+- ❌ Unclear error messages
+- ❌ Not validating configuration before execution
+- ❌ Hardcoding configuration values
+
+## References
+
+- [Cobra CLI Framework](https://github.com/spf13/cobra)
+- [The Twelve-Factor App](https://12factor.net/)
+- [Infrastructure as Code Principles](https://www.hashicorp.com/resources/what-is-infrastructure-as-code)
+

package/augment-extensions/coding-standards/go/templates/prompts/distributed.md

@@ -0,0 +1,133 @@
+# Distributed Systems Go Application AI Template
+
+## Context
+
+You are building a distributed system in Go with consensus, event sourcing, and distributed caching capabilities.
+
+## Key Requirements
+
+### Consensus and Coordination
+- Use HashiCorp Raft or etcd/raft for consensus
+- Implement proper FSM (Finite State Machine) with deterministic apply logic
+- Handle leader election and follower states correctly
+- Implement read consistency levels (strong vs eventual)
+- Handle network partitions gracefully with retries
+
+### Event Sourcing
+- Design immutable events with all necessary information
+- Implement event store interface for persistence
+- Use aggregate root pattern for consistency boundaries
+- Build projections for read models (CQRS pattern)
+- Support event versioning for schema evolution
+
+### Distributed Caching
+- Implement cache-aside (lazy loading) pattern
+- Set appropriate TTLs on all cached items
+- Handle cache failures gracefully with fallback to database
+- Implement cache invalidation on data changes
+- Use pipelining for batch operations
+
+## Code Structure
+
+```go
+// Event sourcing
+type Event struct {
+    ID          string
+    AggregateID string
+    Type        string
+    Data        json.RawMessage
+    Timestamp   time.Time
+    Version     int
+}
+
+type EventStore interface {
+    Save(ctx context.Context, events []Event) error
+    Load(ctx context.Context, aggregateID string) ([]Event, error)
+}
+
+// Caching
+type CacheManager struct {
+    client *redis.Client
+}
+
+func (cm *CacheManager) Get(ctx context.Context, key string) (string, error)
+func (cm *CacheManager) Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error
+```
+
+## Example Patterns
+
+### Consensus with Raft
+```go
+func NewRaftNode(nodeID, raftDir, raftBind string) (*raft.Raft, error) {
+    config := raft.DefaultConfig()
+    config.LocalID = raft.ServerID(nodeID)
+    
+    store, _ := raftboltdb.NewBoltStore(filepath.Join(raftDir, "raft.db"))
+    snapshots, _ := raft.NewFileSnapshotStore(raftDir, 2, os.Stderr)
+    transport, _ := raft.NewTCPTransport(raftBind, nil, 3, 10*time.Second, os.Stderr)
+    
+    return raft.NewRaft(config, fsm, store, store, snapshots, transport)
+}
+```
+
+### Event Sourcing
+```go
+func (u *User) ChangeEmail(newEmail string) error {
+    event := Event{
+        ID:          uuid.New().String(),
+        AggregateID: u.ID,
+        Type:        "UserEmailChanged",
+        Data:        json.Marshal(map[string]string{"new_email": newEmail}),
+        Timestamp:   time.Now(),
+        Version:     u.Version + 1,
+    }
+    
+    u.changes = append(u.changes, event)
+    return u.ApplyEvent(event)
+}
+```
+
+### Distributed Caching
+```go
+func GetUserWithCache(ctx context.Context, cache *redis.Client, db *sql.DB, userID string) (*User, error) {
+    // Try cache first
+    cacheKey := fmt.Sprintf("user:%s", userID)
+    if cached, err := cache.Get(ctx, cacheKey).Result(); err == nil {
+        var user User
+        json.Unmarshal([]byte(cached), &user)
+        return &user, nil
+    }
+    
+    // Cache miss - load from database
+    user, _ := loadUserFromDB(ctx, db, userID)
+    
+    // Store in cache
+    data, _ := json.Marshal(user)
+    cache.Set(ctx, cacheKey, data, 1*time.Hour)
+    
+    return user, nil
+}
+```
+
+## Best Practices
+
+1. **Idempotency**: All operations should be idempotent
+2. **Timeouts**: Set appropriate timeouts for all distributed operations
+3. **Retries**: Implement exponential backoff for retries
+4. **Monitoring**: Add metrics for consensus state, cache hit rates, event processing
+5. **Testing**: Test network partition scenarios
+
+## Common Pitfalls to Avoid
+
+- ❌ Not handling leader election failures
+- ❌ Mutable events in event sourcing
+- ❌ Not setting TTLs on cached items
+- ❌ Blocking operations in FSM apply
+- ❌ Not implementing proper snapshot/restore
+
+## References
+
+- [HashiCorp Raft](https://github.com/hashicorp/raft)
+- [Event Sourcing Pattern](https://martinfowler.com/eaaDev/EventSourcing.html)
+- [Redis Best Practices](https://redis.io/docs/manual/patterns/)
+

package/augment-extensions/coding-standards/go/templates/prompts/microservices.md

@@ -0,0 +1,225 @@
+# Microservice Project Template
+
+## Context
+
+You are generating Go code for a **microservice** project. This includes gRPC services, service discovery, distributed tracing, and metrics.
+
+## Standards
+
+Follow these Go coding standards for microservices:
+
+### Universal Rules
+
+1. **Naming Conventions**: Use MixedCaps for exported names, mixedCaps for unexported
+2. **Error Handling**: Return errors explicitly, use `errors.Is/As` for error inspection
+3. **Concurrency**: Use goroutines and channels properly, always pass context
+4. **Testing**: Write table-driven tests, use mocks for external dependencies
+5. **Code Organization**: Keep packages flat and focused
+6. **Documentation**: Add godoc comments for all exported functions
+7. **Performance**: Minimize allocations, use connection pooling
+
+### Microservices Rules
+
+#### gRPC Services
+- Define services using Protocol Buffers (proto3)
+- Use gRPC status codes for errors (InvalidArgument, NotFound, Internal, etc.)
+- Implement unary and stream interceptors for logging, auth, metrics
+- Set appropriate timeouts using context (typically 5 seconds)
+- Use server-side streaming for large result sets
+
+#### Service Discovery
+- Register service with discovery system (Consul, etcd, Kubernetes) on startup
+- Implement `/health` and `/ready` endpoints for health checks
+- Deregister service during graceful shutdown
+- Use service discovery client to find other services
+- Handle service unavailability gracefully
+
+#### Distributed Tracing
+- Initialize OpenTelemetry tracer on startup
+- Create spans for significant operations
+- Propagate trace context across service boundaries
+- Add relevant attributes to spans (user_id, order_id, etc.)
+- Record errors in spans
+
+#### Metrics
+- Implement RED metrics (Rate, Errors, Duration)
+- Use appropriate metric types (Counter, Gauge, Histogram)
+- Expose metrics on `/metrics` endpoint
+- Add business-specific metrics
+- Avoid high cardinality labels
+
+## Key Requirements
+
+### gRPC Server Setup
+```go
+grpcServer := grpc.NewServer(
+    grpc.ChainUnaryInterceptor(
+        recoveryUnaryInterceptor(logger),
+        loggingUnaryInterceptor(logger),
+        metricsUnaryInterceptor(),
+    ),
+)
+```
+
+### Service Implementation Pattern
+```go
+func (s *UserService) GetUser(ctx context.Context, req *userv1.GetUserRequest) (*userv1.GetUserResponse, error) {
+    if req.Id <= 0 {
+        return nil, status.Error(codes.InvalidArgument, "user ID must be positive")
+    }
+    
+    user, err := s.repo.GetUser(ctx, req.Id)
+    if err != nil {
+        if errors.Is(err, ErrNotFound) {
+            return nil, status.Error(codes.NotFound, "user not found")
+        }
+        return nil, status.Error(codes.Internal, "internal error")
+    }
+    
+    return &userv1.GetUserResponse{User: user}, nil
+}
+```
+
+### Service Registration
+```go
+func (r *ServiceRegistry) Register(ctx context.Context) error {
+    registration := &api.AgentServiceRegistration{
+        ID:      r.serviceID,
+        Name:    r.serviceName,
+        Port:    r.port,
+        Address: getLocalIP(),
+        Check: &api.AgentServiceCheck{
+            HTTP:     fmt.Sprintf("http://%s:%d/health", getLocalIP(), r.port),
+            Interval: "10s",
+            Timeout:  "3s",
+        },
+    }
+    return r.client.Agent().ServiceRegister(registration)
+}
+```
+
+### Distributed Tracing
+```go
+func (s *UserService) GetUser(ctx context.Context, id int64) (*User, error) {
+    tracer := otel.Tracer("user-service")
+    ctx, span := tracer.Start(ctx, "GetUser")
+    defer span.End()
+    
+    span.SetAttributes(attribute.Int64("user.id", id))
+    
+    user, err := s.repo.GetUser(ctx, id)
+    if err != nil {
+        span.RecordError(err)
+        span.SetStatus(codes.Error, err.Error())
+        return nil, err
+    }
+    
+    return user, nil
+}
+```
+
+### Metrics
+```go
+var (
+    requestsTotal = promauto.NewCounterVec(
+        prometheus.CounterOpts{
+            Name: "grpc_requests_total",
+            Help: "Total gRPC requests",
+        },
+        []string{"method", "status"},
+    )
+    
+    requestDuration = promauto.NewHistogramVec(
+        prometheus.HistogramOpts{
+            Name:    "grpc_request_duration_seconds",
+            Help:    "gRPC request duration",
+            Buckets: prometheus.DefBuckets,
+        },
+        []string{"method"},
+    )
+)
+```
+
+## Common Patterns
+
+### Proto3 Service Definition
+```protobuf
+syntax = "proto3";
+
+package user.v1;
+
+service UserService {
+  rpc GetUser(GetUserRequest) returns (GetUserResponse);
+  rpc CreateUser(CreateUserRequest) returns (CreateUserResponse);
+}
+
+message User {
+  int64 id = 1;
+  string name = 2;
+  string email = 3;
+}
+```
+
+### Health Check Endpoints
+```go
+func (h *HealthChecker) Ready(w http.ResponseWriter, r *http.Request) {
+    ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
+    defer cancel()
+    
+    if err := h.db.PingContext(ctx); err != nil {
+        w.WriteHeader(http.StatusServiceUnavailable)
+        return
+    }
+    
+    w.WriteHeader(http.StatusOK)
+}
+```
+
+### Graceful Shutdown
+```go
+func main() {
+    srv := NewServer()
+    registry := NewServiceRegistry()
+    
+    registry.Register(context.Background())
+    
+    go srv.Start()
+    
+    quit := make(chan os.Signal, 1)
+    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+    <-quit
+    
+    registry.Deregister()
+    srv.Stop()
+}
+```
+
+## Tools
+
+Ensure generated code passes:
+- `go build` - Compiles without errors
+- `golangci-lint run` - Passes all linters
+- `go vet` - No suspicious constructs
+- `gofmt -d .` - Properly formatted
+- `go test -race` - No race conditions
+
+## Output Format
+
+Generate complete, production-ready Go code with:
+- Package declaration and imports
+- Protocol Buffer definitions (if applicable)
+- gRPC service implementation
+- Interceptors for logging, recovery, metrics
+- Service registration/discovery
+- Distributed tracing instrumentation
+- Prometheus metrics
+- Graceful shutdown
+- Comprehensive godoc comments
+
+## References
+
+- [gRPC Go](https://grpc.io/docs/languages/go/)
+- [OpenTelemetry Go](https://opentelemetry.io/docs/instrumentation/go/)
+- [Prometheus Go Client](https://github.com/prometheus/client_golang)
+- [Consul Service Discovery](https://www.consul.io/)
+