devflow-kit 1.0.0 → 1.2.0

package/plugins/devflow-go/skills/go/references/detection.md

@@ -0,0 +1,129 @@
+# Go Issue Detection
+
+Grep and regex patterns for finding common Go issues. Reference from main SKILL.md.
+
+## Error Handling Detection
+
+### Unchecked Errors
+
+```bash
+# Find ignored error returns (blank identifier)
+grep -rn ', _ := ' --include='*.go' .
+grep -rn ', _ = ' --include='*.go' .
+
+# Find bare error returns without wrapping
+grep -rn 'return.*err$' --include='*.go' . | grep -v 'fmt.Errorf' | grep -v ':= err'
+
+# Find deferred calls that return errors (Close, Flush, Sync)
+grep -rn 'defer.*\.Close()' --include='*.go' .
+grep -rn 'defer.*\.Flush()' --include='*.go' .
+```
+
+### Missing Error Context
+
+```bash
+# Find raw error returns (no wrapping)
+grep -rn 'return nil, err$' --include='*.go' .
+grep -rn 'return err$' --include='*.go' .
+```
+
+---
+
+## Concurrency Detection
+
+### Goroutine Without Context
+
+```bash
+# Find goroutines that don't reference ctx
+grep -rn 'go func()' --include='*.go' .
+
+# Find goroutines without done/cancel/ctx
+grep -B5 -A10 'go func' --include='*.go' . | grep -L 'ctx\|done\|cancel\|errgroup'
+```
+
+### Potential Goroutine Leaks
+
+```bash
+# Find unbuffered channel creation followed by goroutine
+grep -rn 'make(chan ' --include='*.go' . | grep -v ', [0-9]'
+
+# Find goroutines with infinite loops
+grep -A5 'go func' --include='*.go' . | grep 'for {'
+```
+
+---
+
+## Interface Detection
+
+### Empty Interface Usage
+
+```bash
+# Find empty interface (pre-1.18 style)
+grep -rn 'interface{}' --include='*.go' .
+
+# Find any type (1.18+ style) - may be intentional, review context
+grep -rn '\bany\b' --include='*.go' . | grep -v '_test.go' | grep -v 'vendor/'
+```
+
+### Large Interfaces
+
+```bash
+# Find interface declarations and count methods (interfaces > 5 methods)
+grep -B1 -A20 'type.*interface {' --include='*.go' .
+```
+
+---
+
+## Panic Detection
+
+### Panic in Library Code
+
+```bash
+# Find panic calls outside main/test
+grep -rn 'panic(' --include='*.go' . | grep -v '_test.go' | grep -v 'main.go'
+
+# Find log.Fatal (calls os.Exit) in library code
+grep -rn 'log.Fatal' --include='*.go' . | grep -v 'main.go' | grep -v '_test.go'
+
+# Find os.Exit in library code
+grep -rn 'os.Exit' --include='*.go' . | grep -v 'main.go' | grep -v '_test.go'
+```
+
+---
+
+## init() Detection
+
+```bash
+# Find all init functions
+grep -rn '^func init()' --include='*.go' .
+
+# Find init functions with side effects (network, file, global state)
+grep -A10 '^func init()' --include='*.go' . | grep -E 'http\.|sql\.|os\.|Open|Dial|Connect'
+```
+
+---
+
+## Mutex and Race Detection
+
+```bash
+# Find mutex passed by value (function params with Mutex, not pointer)
+grep -rn 'func.*sync\.Mutex[^*]' --include='*.go' .
+
+# Find Lock without corresponding Unlock
+grep -rn '\.Lock()' --include='*.go' . | grep -v 'defer.*Unlock'
+
+# Find RLock without RUnlock
+grep -rn '\.RLock()' --include='*.go' . | grep -v 'defer.*RUnlock'
+```
+
+---
+
+## Map and Slice Safety
+
+```bash
+# Find uninitialized map declarations (potential nil map panic)
+grep -rn 'var.*map\[' --include='*.go' . | grep -v 'make\|:='
+
+# Find slice append without pre-allocation hint
+grep -rn 'append(' --include='*.go' . | head -20
+```

package/plugins/devflow-go/skills/go/references/patterns.md

@@ -0,0 +1,232 @@
+# Go Correct Patterns
+
+Extended correct patterns for Go development. Reference from main SKILL.md.
+
+## Table-Driven Tests
+
+```go
+func TestAdd(t *testing.T) {
+    tests := []struct {
+        name     string
+        a, b     int
+        expected int
+    }{
+        {"positive numbers", 2, 3, 5},
+        {"negative numbers", -1, -2, -3},
+        {"zero", 0, 0, 0},
+        {"mixed signs", -1, 3, 2},
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            result := Add(tt.a, tt.b)
+            if result != tt.expected {
+                t.Errorf("Add(%d, %d) = %d, want %d", tt.a, tt.b, result, tt.expected)
+            }
+        })
+    }
+}
+```
+
+---
+
+## Functional Options
+
+```go
+type Server struct {
+    addr    string
+    timeout time.Duration
+    logger  *slog.Logger
+}
+
+type Option func(*Server)
+
+func WithAddr(addr string) Option {
+    return func(s *Server) { s.addr = addr }
+}
+
+func WithTimeout(d time.Duration) Option {
+    return func(s *Server) { s.timeout = d }
+}
+
+func WithLogger(l *slog.Logger) Option {
+    return func(s *Server) { s.logger = l }
+}
+
+func NewServer(opts ...Option) *Server {
+    s := &Server{
+        addr:    ":8080",           // sensible default
+        timeout: 30 * time.Second,  // sensible default
+        logger:  slog.Default(),
+    }
+    for _, opt := range opts {
+        opt(s)
+    }
+    return s
+}
+
+// Usage
+srv := NewServer(
+    WithAddr(":9090"),
+    WithTimeout(60 * time.Second),
+)
+```
+
+---
+
+## Custom Error Types
+
+```go
+type ValidationError struct {
+    Field   string
+    Message string
+}
+
+func (e *ValidationError) Error() string {
+    return fmt.Sprintf("validation failed on %s: %s", e.Field, e.Message)
+}
+
+type NotFoundError struct {
+    Resource string
+    ID       string
+}
+
+func (e *NotFoundError) Error() string {
+    return fmt.Sprintf("%s %s not found", e.Resource, e.ID)
+}
+
+// Usage with errors.As
+func handleErr(err error) {
+    var validErr *ValidationError
+    if errors.As(err, &validErr) {
+        log.Printf("bad input: field=%s msg=%s", validErr.Field, validErr.Message)
+        return
+    }
+    var notFound *NotFoundError
+    if errors.As(err, &notFound) {
+        log.Printf("missing: %s/%s", notFound.Resource, notFound.ID)
+        return
+    }
+    log.Printf("unexpected: %v", err)
+}
+```
+
+---
+
+## Middleware Pattern
+
+```go
+type Middleware func(http.Handler) http.Handler
+
+func Logging(logger *slog.Logger) Middleware {
+    return func(next http.Handler) http.Handler {
+        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+            start := time.Now()
+            next.ServeHTTP(w, r)
+            logger.Info("request",
+                "method", r.Method,
+                "path", r.URL.Path,
+                "duration", time.Since(start),
+            )
+        })
+    }
+}
+
+func Recovery() Middleware {
+    return func(next http.Handler) http.Handler {
+        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+            defer func() {
+                if err := recover(); err != nil {
+                    w.WriteHeader(http.StatusInternalServerError)
+                    slog.Error("panic recovered", "error", err)
+                }
+            }()
+            next.ServeHTTP(w, r)
+        })
+    }
+}
+
+// Chain composes middleware in order
+func Chain(handler http.Handler, middlewares ...Middleware) http.Handler {
+    for i := len(middlewares) - 1; i >= 0; i-- {
+        handler = middlewares[i](handler)
+    }
+    return handler
+}
+
+// Usage
+mux := http.NewServeMux()
+mux.HandleFunc("/api/users", handleUsers)
+handler := Chain(mux, Recovery(), Logging(logger))
+```
+
+---
+
+## Graceful Shutdown
+
+```go
+func main() {
+    srv := &http.Server{Addr: ":8080", Handler: mux}
+
+    go func() {
+        if err := srv.ListenAndServe(); err != http.ErrServerClosed {
+            slog.Error("server error", "error", err)
+        }
+    }()
+
+    quit := make(chan os.Signal, 1)
+    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+    <-quit
+
+    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+    defer cancel()
+
+    if err := srv.Shutdown(ctx); err != nil {
+        slog.Error("shutdown error", "error", err)
+    }
+    slog.Info("server stopped")
+}
+```
+
+---
+
+## Constructor Pattern
+
+```go
+// Validate at construction - enforce invariants
+func NewUser(name, email string) (*User, error) {
+    if name == "" {
+        return nil, &ValidationError{Field: "name", Message: "required"}
+    }
+    if !strings.Contains(email, "@") {
+        return nil, &ValidationError{Field: "email", Message: "invalid format"}
+    }
+    return &User{
+        ID:        uuid.New().String(),
+        Name:      name,
+        Email:     email,
+        CreatedAt: time.Now(),
+    }, nil
+}
+```
+
+---
+
+## Structured Logging with slog
+
+```go
+func ProcessOrder(ctx context.Context, orderID string) error {
+    logger := slog.With("order_id", orderID, "trace_id", traceID(ctx))
+
+    logger.Info("processing order")
+
+    items, err := fetchItems(ctx, orderID)
+    if err != nil {
+        logger.Error("failed to fetch items", "error", err)
+        return fmt.Errorf("fetching items for order %s: %w", orderID, err)
+    }
+
+    logger.Info("items fetched", "count", len(items))
+    return nil
+}
+```

package/plugins/devflow-go/skills/go/references/violations.md

@@ -0,0 +1,205 @@
+# Go Violation Examples
+
+Extended violation patterns for Go reviews. Reference from main SKILL.md.
+
+## Error Handling Violations
+
+### Ignored Errors
+
+```go
+// VIOLATION: Silently discarding error
+data, _ := json.Marshal(user)
+w.Write(data)
+
+// VIOLATION: Error ignored in deferred call
+defer file.Close() // Close() returns error
+
+// VIOLATION: Swallowing error with log
+if err != nil {
+    log.Println("something failed") // Error details lost
+    return nil
+}
+```
+
+### Unwrapped Errors
+
+```go
+// VIOLATION: No context on error
+func LoadConfig(path string) (*Config, error) {
+    data, err := os.ReadFile(path)
+    if err != nil {
+        return nil, err // Caller has no idea what failed
+    }
+    var cfg Config
+    if err := json.Unmarshal(data, &cfg); err != nil {
+        return nil, err // Which unmarshal? What file?
+    }
+    return &cfg, nil
+}
+```
+
+---
+
+## Goroutine Leak Violations
+
+### Fire-and-Forget Goroutine
+
+```go
+// VIOLATION: No way to stop or wait for this goroutine
+func StartPoller() {
+    go func() {
+        for {
+            poll()
+            time.Sleep(10 * time.Second)
+        }
+    }()
+}
+
+// VIOLATION: Goroutine blocks forever on channel nobody reads
+func process(items []Item) {
+    ch := make(chan Result)
+    for _, item := range items {
+        go func(i Item) {
+            ch <- compute(i) // Blocks if nobody reads
+        }(item)
+    }
+    // Only reads first result - rest leak
+    result := <-ch
+    _ = result
+}
+```
+
+### Missing Context Cancellation
+
+```go
+// VIOLATION: Goroutine ignores context
+func Fetch(ctx context.Context, url string) ([]byte, error) {
+    ch := make(chan []byte, 1)
+    go func() {
+        resp, _ := http.Get(url) // Ignores ctx cancellation
+        body, _ := io.ReadAll(resp.Body)
+        ch <- body
+    }()
+    return <-ch, nil
+}
+```
+
+---
+
+## Interface Pollution Violations
+
+### Premature Interface Definition
+
+```go
+// VIOLATION: Interface defined at producer, not consumer
+package user
+
+type UserStore interface { // Only one implementation exists
+    Get(id string) (*User, error)
+    Save(u *User) error
+    Delete(id string) error
+    List() ([]*User, error)
+    Count() (int, error)
+}
+
+type PostgresStore struct{ db *sql.DB }
+
+func (s *PostgresStore) Get(id string) (*User, error) { ... }
+// ... implements all 5 methods
+```
+
+### God Interface
+
+```go
+// VIOLATION: Interface too large - impossible to mock cleanly
+type Service interface {
+    CreateUser(ctx context.Context, u *User) error
+    GetUser(ctx context.Context, id string) (*User, error)
+    UpdateUser(ctx context.Context, u *User) error
+    DeleteUser(ctx context.Context, id string) error
+    ListUsers(ctx context.Context) ([]*User, error)
+    SendEmail(ctx context.Context, to string, body string) error
+    GenerateReport(ctx context.Context) ([]byte, error)
+    ProcessPayment(ctx context.Context, amt int) error
+}
+```
+
+---
+
+## Naked Return Violations
+
+```go
+// VIOLATION: Naked returns obscure what's being returned
+func divide(a, b float64) (result float64, err error) {
+    if b == 0 {
+        err = errors.New("division by zero")
+        return // What is result here? Zero - but not obvious
+    }
+    result = a / b
+    return // Have to trace back to find return values
+}
+```
+
+---
+
+## init() Abuse Violations
+
+```go
+// VIOLATION: Side effects in init - runs on import
+func init() {
+    db, err := sql.Open("postgres", os.Getenv("DATABASE_URL"))
+    if err != nil {
+        log.Fatal(err) // Crashes on import
+    }
+    globalDB = db
+}
+
+// VIOLATION: Registration magic in init
+func init() {
+    http.HandleFunc("/health", healthCheck) // Hidden route registration
+    prometheus.MustRegister(requestCounter) // Panics if called twice
+}
+```
+
+---
+
+## Mutex Violations
+
+```go
+// VIOLATION: Copying mutex (passes by value)
+type Cache struct {
+    mu   sync.Mutex
+    data map[string]string
+}
+
+func process(c Cache) { // c is a COPY - mutex is copied too
+    c.mu.Lock()
+    defer c.mu.Unlock()
+    c.data["key"] = "val"
+}
+
+// VIOLATION: Forgetting to unlock
+func (c *Cache) Get(key string) string {
+    c.mu.Lock()
+    if val, ok := c.data[key]; ok {
+        return val // Mutex never unlocked!
+    }
+    c.mu.Unlock()
+    return ""
+}
+```
+
+---
+
+## Slice and Map Violations
+
+```go
+// VIOLATION: Nil map write (runtime panic)
+var m map[string]int
+m["key"] = 1 // panic: assignment to entry in nil map
+
+// VIOLATION: Sharing slice backing array
+func getFirstThree(s []int) []int {
+    return s[:3] // Shares backing array - mutations leak
+}
+```

package/plugins/devflow-implement/.claude-plugin/plugin.json

@@ -5,16 +5,14 @@
     "name": "DevFlow Contributors",
     "email": "dean@keren.dev"
   },
-  "version": "1.0.0",
+  "version": "1.2.0",
   "homepage": "https://github.com/dean0x/devflow",
   "repository": "https://github.com/dean0x/devflow",
   "license": "MIT",
   "keywords": ["implementation", "coding", "workflow", "agents", "agentic", "pr"],
   "agents": ["git", "skimmer", "synthesizer", "coder", "simplifier", "scrutinizer", "shepherd", "validator"],
   "skills": [
-    "accessibility",
     "agent-teams",
-    "frontend-design",
     "implementation-patterns",
     "self-review"
   ]

package/plugins/devflow-implement/agents/coder.md

@@ -2,7 +2,7 @@
 name: Coder
 description: Autonomous task implementation on feature branch. Implements, tests, and commits.
 model: inherit
-skills: core-patterns, git-safety, implementation-patterns, git-workflow, typescript, react, test-patterns, input-validation, accessibility, frontend-design
+skills: core-patterns, git-safety, implementation-patterns, git-workflow, test-patterns, input-validation
 ---
 
 # Coder Agent
@@ -33,11 +33,16 @@ You receive from orchestrator:
 
 2. **Reference handoff** (if PRIOR_PHASE_SUMMARY provided): Use summary to validate your understanding of prior work, not as the sole source of truth. The actual code is authoritative.
 
-3. **Load domain skills**: Based on DOMAIN hint, apply relevant patterns:
-   - `backend`: typescript, implementation-patterns, input-validation
-   - `frontend`: react, typescript, accessibility, frontend-design
-   - `tests`: test-patterns, typescript
-   - `fullstack`: all of the above
+3. **Load domain skills**: Based on DOMAIN hint and files in scope, dynamically load relevant language/ecosystem skills by reading their SKILL.md. Only load skills that are installed:
+   - `backend` (TypeScript): Read `~/.claude/skills/typescript/SKILL.md`, `~/.claude/skills/input-validation/SKILL.md`
+   - `backend` (Go): Read `~/.claude/skills/go/SKILL.md`
+   - `backend` (Java): Read `~/.claude/skills/java/SKILL.md`
+   - `backend` (Python): Read `~/.claude/skills/python/SKILL.md`
+   - `backend` (Rust): Read `~/.claude/skills/rust/SKILL.md`
+   - `frontend`: Read `~/.claude/skills/react/SKILL.md`, `~/.claude/skills/typescript/SKILL.md`, `~/.claude/skills/accessibility/SKILL.md`, `~/.claude/skills/frontend-design/SKILL.md`
+   - `tests`: Read `~/.claude/skills/test-patterns/SKILL.md`, `~/.claude/skills/typescript/SKILL.md`
+   - `fullstack`: Combine backend + frontend skills
+   - If a Read fails (skill not installed), skip it silently and continue.
 
 4. **Implement the plan**: Work through execution steps systematically, creating and modifying files. Follow existing patterns. Type everything. Use Result types if codebase uses them.
 

package/plugins/devflow-java/.claude-plugin/plugin.json

@@ -0,0 +1,15 @@
+{
+  "name": "devflow-java",
+  "description": "Java language patterns - records, sealed classes, composition, modern Java features",
+  "author": {
+    "name": "DevFlow Contributors",
+    "email": "dean@keren.dev"
+  },
+  "version": "1.2.0",
+  "homepage": "https://github.com/dean0x/devflow",
+  "repository": "https://github.com/dean0x/devflow",
+  "license": "MIT",
+  "keywords": ["java", "records", "sealed-classes", "composition"],
+  "agents": [],
+  "skills": ["java"]
+}