devflow-kit 1.1.0 → 1.2.0

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.1.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"]
+}

package/plugins/devflow-java/skills/java/SKILL.md

@@ -0,0 +1,183 @@
+---
+name: java
+description: This skill should be used when the user works with Java files (.java), asks about "records", "sealed classes", "Optional", "streams", "composition over inheritance", or discusses modern Java patterns and API design. Provides patterns for type system usage, error handling, immutability, and concurrency.
+user-invocable: false
+allowed-tools: Read, Grep, Glob
+activation:
+  file-patterns:
+    - "**/*.java"
+  exclude:
+    - "**/build/**"
+    - "**/target/**"
+---
+
+# Java Patterns
+
+Reference for modern Java patterns, type system, and best practices.
+
+## Iron Law
+
+> **FAVOR COMPOSITION OVER INHERITANCE**
+>
+> Delegation and interfaces over class hierarchies. Inheritance creates tight coupling,
+> breaks encapsulation, and makes refactoring dangerous. Use interfaces for polymorphism,
+> records for data, and sealed classes for restricted hierarchies. Extend only when the
+> "is-a" relationship is genuinely invariant.
+
+## When This Skill Activates
+
+- Working with Java codebases
+- Designing APIs with modern Java features
+- Using records, sealed classes, Optional
+- Implementing concurrent code
+- Structuring Java packages
+
+---
+
+## Type System (Modern Java)
+
+### Records for Data
+
+```java
+// BAD: Mutable POJO with getters/setters
+// GOOD: Immutable record
+public record User(String name, String email, Instant createdAt) {
+    public User {
+        Objects.requireNonNull(name, "name must not be null");
+        Objects.requireNonNull(email, "email must not be null");
+    }
+}
+```
+
+### Sealed Classes for Restricted Hierarchies
+
+```java
+public sealed interface Result<T> permits Success, Failure {
+    record Success<T>(T value) implements Result<T> {}
+    record Failure<T>(String error) implements Result<T> {}
+}
+
+// Exhaustive pattern matching (Java 21+)
+switch (result) {
+    case Success<User> s -> handleSuccess(s.value());
+    case Failure<User> f -> handleError(f.error());
+}
+```
+
+### Optional for Absent Values
+
+```java
+// BAD: return null;
+// GOOD:
+public Optional<User> findById(String id) {
+    return Optional.ofNullable(userMap.get(id));
+}
+
+// BAD: if (optional.isPresent()) optional.get()
+// GOOD:
+optional.map(User::name).orElse("Anonymous");
+```
+
+---
+
+## Error Handling
+
+### Custom Exceptions with Context
+
+```java
+public class EntityNotFoundException extends RuntimeException {
+    private final String entityType;
+    private final String entityId;
+
+    public EntityNotFoundException(String entityType, String entityId) {
+        super("%s with id %s not found".formatted(entityType, entityId));
+        this.entityType = entityType;
+        this.entityId = entityId;
+    }
+}
+```
+
+### Try-with-Resources
+
+```java
+// Always use try-with-resources for AutoCloseable
+try (var conn = dataSource.getConnection();
+     var stmt = conn.prepareStatement(sql)) {
+    stmt.setString(1, id);
+    return mapResult(stmt.executeQuery());
+}
+```
+
+---
+
+## Immutability
+
+```java
+// Prefer unmodifiable collections
+List<String> names = List.of("Alice", "Bob");
+Map<String, Integer> scores = Map.of("Alice", 100, "Bob", 95);
+
+// Defensive copies in constructors
+public final class Team {
+    private final List<String> members;
+    public Team(List<String> members) {
+        this.members = List.copyOf(members);
+    }
+    public List<String> members() { return members; }
+}
+```
+
+---
+
+## Composition Over Inheritance
+
+```java
+// BAD: class UserService extends BaseService extends AbstractDAO
+// GOOD: compose via constructor injection
+public class UserService {
+    private final UserRepository repository;
+    private final EventPublisher events;
+
+    public UserService(UserRepository repository, EventPublisher events) {
+        this.repository = repository;
+        this.events = events;
+    }
+}
+```
+
+---
+
+## Anti-Patterns
+
+| Pattern | Bad | Good |
+|---------|-----|------|
+| Returning null | `return null` | `return Optional.empty()` |
+| Checked exception abuse | `throws Exception` | Specific exceptions or unchecked |
+| Raw types | `List list` | `List<User> list` |
+| Deep inheritance | 4+ level hierarchy | Interfaces + composition |
+| Mutable data objects | `setName()/getName()` | Records or immutable classes |
+
+---
+
+## Extended References
+
+For additional patterns and examples:
+- `references/violations.md` - Common Java violations
+- `references/patterns.md` - Extended Java patterns
+- `references/detection.md` - Detection patterns for Java issues
+- `references/modern-java.md` - Modern Java features (17-21+)
+
+---
+
+## Checklist
+
+- [ ] Records for pure data types
+- [ ] Sealed interfaces for type hierarchies
+- [ ] Optional instead of null returns
+- [ ] Composition over inheritance
+- [ ] Try-with-resources for all AutoCloseable
+- [ ] Immutable collections (List.of, Map.of)
+- [ ] No raw generic types
+- [ ] Custom exceptions with context
+- [ ] Streams for collection transforms
+- [ ] Constructor injection for dependencies

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

@@ -0,0 +1,120 @@
+# Detection Patterns for Java Issues
+
+Grep and regex patterns for automated detection of Java violations. Reference from main SKILL.md.
+
+---
+
+## Null Returns
+
+```bash
+# Methods returning null instead of Optional
+rg 'return\s+null\s*;' --type java
+
+# Nullable method parameters without validation
+rg 'public\s+\w+\s+\w+\((?!.*@NonNull).*\)' --type java
+```
+
+---
+
+## Raw Types
+
+```bash
+# Raw List, Map, Set, Collection usage
+rg '\b(List|Map|Set|Collection|Iterator|Iterable)\b(?!\s*<)' --type java
+
+# Raw Comparable implementation
+rg 'implements\s+Comparable\b(?!\s*<)' --type java
+
+# Unsafe casts from Object
+rg '\(\s*(String|Integer|Long|Double)\s*\)\s*\w+\.get' --type java
+```
+
+---
+
+## Deep Inheritance
+
+```bash
+# Classes extending non-Object/non-interface classes (potential deep hierarchy)
+rg 'class\s+\w+\s+extends\s+(?!Object\b)\w+' --type java
+
+# Abstract class chains (look for multiple levels)
+rg 'abstract\s+class\s+\w+\s+extends\s+Abstract' --type java
+
+# Count inheritance depth per file
+rg 'extends\s+\w+' --type java --count
+```
+
+---
+
+## Missing Try-with-Resources
+
+```bash
+# Manual close() calls (should use try-with-resources)
+rg '\.close\(\)\s*;' --type java
+
+# InputStream/OutputStream/Connection created outside try-with-resources
+rg 'new\s+(FileInputStream|FileOutputStream|BufferedReader|BufferedWriter|Socket)\(' --type java
+
+# getConnection() without try-with-resources context
+rg '\.getConnection\(\)' --type java
+```
+
+---
+
+## Checked Exception Abuse
+
+```bash
+# Broad throws declarations
+rg 'throws\s+Exception\b' --type java
+
+# Empty catch blocks
+rg -U 'catch\s*\([^)]+\)\s*\{\s*\}' --type java --multiline
+
+# Catch-and-ignore (catch with only a comment or log)
+rg -U 'catch\s*\([^)]+\)\s*\{\s*(//|/\*|logger\.(debug|trace))' --type java --multiline
+```
+
+---
+
+## Mutable Data Objects
+
+```bash
+# Setter methods (JavaBean anti-pattern for data objects)
+rg 'public\s+void\s+set[A-Z]\w*\(' --type java
+
+# Mutable collections returned from getters
+rg 'return\s+(this\.)?(list|map|set|collection)\s*;' --type java -i
+
+# Missing defensive copies in constructors
+rg 'this\.\w+\s*=\s*\w+\s*;' --type java
+```
+
+---
+
+## Concurrency Issues
+
+```bash
+# HashMap in concurrent context (should be ConcurrentHashMap)
+rg 'new\s+HashMap\b' --type java
+
+# Missing volatile on shared fields
+rg 'private\s+(?!volatile\s)(?!final\s)\w+\s+\w+\s*=' --type java
+
+# Synchronized on non-private lock object
+rg 'synchronized\s*\(\s*this\s*\)' --type java
+```
+
+---
+
+## Streams Anti-Patterns
+
+```bash
+# Stream.forEach with side effects (should use for-loop or collect)
+rg '\.stream\(\).*\.forEach\(' --type java
+
+# Nested streams (performance concern)
+rg '\.stream\(\).*\.stream\(\)' --type java
+
+# collect(Collectors.toList()) instead of .toList() (Java 16+)
+rg 'collect\(Collectors\.toList\(\)\)' --type java
+```