aigroup-workflow 2.1.1 → 2.2.0

package/skills/fullstack-guardian/references/security-checklist.md

@@ -1,106 +0,0 @@
-# Security Checklist
-
-## Per-Feature Security Checklist
-
-| Category | Check | Action |
-|----------|-------|--------|
-| **Auth** | Endpoint requires authentication? | Add auth middleware/guard |
-| **Authz** | User authorized for this action? | Check ownership/role |
-| **Input** | All input validated and sanitized? | Use schemas, sanitize |
-| **Output** | Sensitive data excluded from response? | Filter response fields |
-| **Rate Limit** | Endpoint rate limited? | Add rate limiter |
-| **Logging** | Security events logged? | Log auth failures, changes |
-
-## Authentication Patterns
-
-```typescript
-// NestJS Guard
-@UseGuards(JwtAuthGuard)
-@Get('profile')
-async getProfile(@CurrentUser() user: User) {
-  return this.userService.findById(user.id);
-}
-
-// Express Middleware
-app.get('/profile', authenticate, (req, res) => {
-  res.json(req.user);
-});
-```
-
-```python
-# FastAPI Dependency
-@router.get("/profile")
-async def get_profile(current_user: User = Depends(get_current_user)):
-    return current_user
-```
-
-## Authorization Patterns
-
-```typescript
-// Resource ownership check
-async updatePost(postId: string, userId: string, data: UpdatePostDto) {
-  const post = await this.postRepo.findById(postId);
-
-  if (post.authorId !== userId) {
-    throw new ForbiddenException('Not authorized to edit this post');
-  }
-
-  return this.postRepo.update(postId, data);
-}
-
-// Role-based check
-@Roles('admin')
-@UseGuards(RolesGuard)
-@Delete(':id')
-async deleteUser(@Param('id') id: string) {
-  return this.userService.delete(id);
-}
-```
-
-## Input Validation
-
-```typescript
-// Zod schema
-const CreateUserSchema = z.object({
-  email: z.string().email(),
-  name: z.string().min(1).max(100),
-  password: z.string().min(12),
-});
-
-// Use in endpoint
-const validated = CreateUserSchema.parse(req.body);
-```
-
-```python
-# Pydantic model
-class CreateUser(BaseModel):
-    email: EmailStr
-    name: str = Field(min_length=1, max_length=100)
-    password: str = Field(min_length=12)
-```
-
-## Rate Limiting
-
-```typescript
-// Express rate-limit
-import rateLimit from 'express-rate-limit';
-
-const authLimiter = rateLimit({
-  windowMs: 15 * 60 * 1000, // 15 minutes
-  max: 5, // 5 attempts
-  message: 'Too many login attempts',
-});
-
-app.post('/login', authLimiter, loginHandler);
-```
-
-## Quick Reference
-
-| Risk | Mitigation |
-|------|------------|
-| SQL Injection | Parameterized queries |
-| XSS | Output encoding, CSP |
-| CSRF | CSRF tokens, SameSite cookies |
-| IDOR | Authorization checks |
-| Brute Force | Rate limiting |
-| Data Exposure | Response filtering |

package/skills/golang-pro/SKILL.md

@@ -1,122 +0,0 @@
----
-name: golang-pro
-description: Implements concurrent Go patterns using goroutines and channels, designs and builds microservices with gRPC or REST, optimizes Go application performance with pprof, and enforces idiomatic Go with generics, interfaces, and robust error handling. Use when building Go applications requiring concurrent programming, microservices architecture, or high-performance systems. Invoke for goroutines, channels, Go generics, gRPC integration, CLI tools, benchmarks, or table-driven testing.
-license: MIT
-metadata:
-  author: https://github.com/Jeffallan
-  version: "1.1.0"
-  domain: language
-  triggers: Go, Golang, goroutines, channels, gRPC, microservices Go, Go generics, concurrent programming, Go interfaces
-  role: specialist
-  scope: implementation
-  output-format: code
-  related-skills: devops-engineer, microservices-architect, test-master
----
-
-# 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.
-
-## Core Workflow
-
-1. **Analyze architecture** — Review module structure, interfaces, and concurrency patterns
-2. **Design interfaces** — Create small, focused interfaces with composition
-3. **Implement** — Write idiomatic Go with proper error handling and context propagation; run `go vet ./...` before proceeding
-4. **Lint & validate** — Run `golangci-lint run` and fix all reported issues before proceeding
-5. **Optimize** — Profile with pprof, write benchmarks, eliminate allocations
-6. **Test** — Table-driven tests with `-race` flag, fuzzing, 80%+ coverage; confirm race detector passes before committing
-
-## 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 |
-
-## Core Pattern Example
-
-Goroutine with proper context cancellation and error propagation:
-
-```go
-// worker runs until ctx is cancelled or an error occurs.
-// Errors are returned via the errCh channel; the caller must drain it.
-func worker(ctx context.Context, jobs <-chan Job, errCh chan<- error) {
-    for {
-        select {
-        case <-ctx.Done():
-            errCh <- fmt.Errorf("worker cancelled: %w", ctx.Err())
-            return
-        case job, ok := <-jobs:
-            if !ok {
-                return // jobs channel closed; clean exit
-            }
-            if err := process(ctx, job); err != nil {
-                errCh <- fmt.Errorf("process job %v: %w", job.ID, err)
-                return
-            }
-        }
-    }
-}
-
-func runPipeline(ctx context.Context, jobs []Job) error {
-    ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
-    defer cancel()
-
-    jobCh := make(chan Job, len(jobs))
-    errCh := make(chan error, 1)
-
-    go worker(ctx, jobCh, errCh)
-
-    for _, j := range jobs {
-        jobCh <- j
-    }
-    close(jobCh)
-
-    select {
-    case err := <-errCh:
-        return err
-    case <-ctx.Done():
-        return fmt.Errorf("pipeline timed out: %w", ctx.Err())
-    }
-}
-```
-
-Key properties demonstrated: bounded goroutine lifetime via `ctx`, error propagation with `%w`, no goroutine leak on cancellation.
-
-## 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

package/skills/golang-pro/references/concurrency.md

@@ -1,329 +0,0 @@
-# Concurrency Patterns
-
-## Goroutine Lifecycle Management
-
-```go
-package main
-
-import (
-    "context"
-    "fmt"
-    "sync"
-    "time"
-)
-
-// Worker pool with bounded concurrency
-type WorkerPool struct {
-    workers int
-    tasks   chan func()
-    wg      sync.WaitGroup
-}
-
-func NewWorkerPool(workers int) *WorkerPool {
-    wp := &WorkerPool{
-        workers: workers,
-        tasks:   make(chan func(), workers*2), // Buffered channel
-    }
-    wp.start()
-    return wp
-}
-
-func (wp *WorkerPool) start() {
-    for i := 0; i < wp.workers; i++ {
-        wp.wg.Add(1)
-        go func() {
-            defer wp.wg.Done()
-            for task := range wp.tasks {
-                task()
-            }
-        }()
-    }
-}
-
-func (wp *WorkerPool) Submit(task func()) {
-    wp.tasks <- task
-}
-
-func (wp *WorkerPool) Shutdown() {
-    close(wp.tasks)
-    wp.wg.Wait()
-}
-```
-
-## Channel Patterns
-
-```go
-// Generator pattern
-func generateNumbers(ctx context.Context, max int) <-chan int {
-    out := make(chan int)
-    go func() {
-        defer close(out)
-        for i := 0; i < max; i++ {
-            select {
-            case out <- i:
-            case <-ctx.Done():
-                return
-            }
-        }
-    }()
-    return out
-}
-
-// Fan-out, fan-in pattern
-func fanOut(ctx context.Context, input <-chan int, workers int) []<-chan int {
-    channels := make([]<-chan int, workers)
-    for i := 0; i < workers; i++ {
-        channels[i] = process(ctx, input)
-    }
-    return channels
-}
-
-func process(ctx context.Context, input <-chan int) <-chan int {
-    out := make(chan int)
-    go func() {
-        defer close(out)
-        for val := range input {
-            select {
-            case out <- val * 2:
-            case <-ctx.Done():
-                return
-            }
-        }
-    }()
-    return out
-}
-
-func fanIn(ctx context.Context, channels ...<-chan int) <-chan int {
-    out := make(chan int)
-    var wg sync.WaitGroup
-
-    for _, ch := range channels {
-        wg.Add(1)
-        go func(c <-chan int) {
-            defer wg.Done()
-            for val := range c {
-                select {
-                case out <- val:
-                case <-ctx.Done():
-                    return
-                }
-            }
-        }(ch)
-    }
-
-    go func() {
-        wg.Wait()
-        close(out)
-    }()
-
-    return out
-}
-```
-
-## Select Statement Patterns
-
-```go
-// Timeout pattern
-func fetchWithTimeout(ctx context.Context, url string) (string, error) {
-    result := make(chan string, 1)
-    errCh := make(chan error, 1)
-
-    go func() {
-        // Simulate network call
-        time.Sleep(100 * time.Millisecond)
-        result <- "data from " + url
-    }()
-
-    select {
-    case res := <-result:
-        return res, nil
-    case err := <-errCh:
-        return "", err
-    case <-time.After(50 * time.Millisecond):
-        return "", fmt.Errorf("timeout")
-    case <-ctx.Done():
-        return "", ctx.Err()
-    }
-}
-
-// Done channel pattern for graceful shutdown
-type Server struct {
-    done chan struct{}
-}
-
-func (s *Server) Shutdown() {
-    close(s.done)
-}
-
-func (s *Server) Run(ctx context.Context) {
-    ticker := time.NewTicker(1 * time.Second)
-    defer ticker.Stop()
-
-    for {
-        select {
-        case <-ticker.C:
-            fmt.Println("tick")
-        case <-s.done:
-            fmt.Println("shutting down")
-            return
-        case <-ctx.Done():
-            fmt.Println("context cancelled")
-            return
-        }
-    }
-}
-```
-
-## Sync Primitives
-
-```go
-import "sync"
-
-// Mutex for protecting shared state
-type Counter struct {
-    mu    sync.Mutex
-    count int
-}
-
-func (c *Counter) Increment() {
-    c.mu.Lock()
-    defer c.mu.Unlock()
-    c.count++
-}
-
-func (c *Counter) Value() int {
-    c.mu.Lock()
-    defer c.mu.Unlock()
-    return c.count
-}
-
-// RWMutex for read-heavy workloads
-type Cache struct {
-    mu    sync.RWMutex
-    items map[string]string
-}
-
-func (c *Cache) Get(key string) (string, bool) {
-    c.mu.RLock()
-    defer c.mu.RUnlock()
-    val, ok := c.items[key]
-    return val, ok
-}
-
-func (c *Cache) Set(key, value string) {
-    c.mu.Lock()
-    defer c.mu.Unlock()
-    c.items[key] = value
-}
-
-// sync.Once for initialization
-type Service struct {
-    once   sync.Once
-    config *Config
-}
-
-func (s *Service) getConfig() *Config {
-    s.once.Do(func() {
-        s.config = loadConfig() // Only called once
-    })
-    return s.config
-}
-```
-
-## Rate Limiting and Backpressure
-
-```go
-import "golang.org/x/time/rate"
-
-// Token bucket rate limiter
-type RateLimiter struct {
-    limiter *rate.Limiter
-}
-
-func NewRateLimiter(rps int) *RateLimiter {
-    return &RateLimiter{
-        limiter: rate.NewLimiter(rate.Limit(rps), rps),
-    }
-}
-
-func (rl *RateLimiter) Process(ctx context.Context, item string) error {
-    if err := rl.limiter.Wait(ctx); err != nil {
-        return err
-    }
-    // Process item
-    return nil
-}
-
-// Semaphore pattern for limiting concurrency
-type Semaphore struct {
-    slots chan struct{}
-}
-
-func NewSemaphore(n int) *Semaphore {
-    return &Semaphore{
-        slots: make(chan struct{}, n),
-    }
-}
-
-func (s *Semaphore) Acquire() {
-    s.slots <- struct{}{}
-}
-
-func (s *Semaphore) Release() {
-    <-s.slots
-}
-
-func (s *Semaphore) Do(fn func()) {
-    s.Acquire()
-    defer s.Release()
-    fn()
-}
-```
-
-## Pipeline Pattern
-
-```go
-// Stage-based processing pipeline
-func pipeline(ctx context.Context, input <-chan int) <-chan int {
-    // Stage 1: Square numbers
-    stage1 := make(chan int)
-    go func() {
-        defer close(stage1)
-        for num := range input {
-            select {
-            case stage1 <- num * num:
-            case <-ctx.Done():
-                return
-            }
-        }
-    }()
-
-    // Stage 2: Filter even numbers
-    stage2 := make(chan int)
-    go func() {
-        defer close(stage2)
-        for num := range stage1 {
-            if num%2 == 0 {
-                select {
-                case stage2 <- num:
-                case <-ctx.Done():
-                    return
-                }
-            }
-        }
-    }()
-
-    return stage2
-}
-```
-
-## Quick Reference
-
-| Pattern | Use Case | Key Points |
-|---------|----------|------------|
-| Worker Pool | Bounded concurrency | Limit goroutines, reuse workers |
-| Fan-out/Fan-in | Parallel processing | Distribute work, merge results |
-| Pipeline | Stream processing | Chain transformations |
-| Rate Limiter | API throttling | Control request rate |
-| Semaphore | Resource limits | Cap concurrent operations |
-| Done Channel | Graceful shutdown | Signal completion |