devflow-kit 1.8.3 → 2.0.1

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

@@ -1,205 +0,0 @@
-# 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

@@ -1,35 +0,0 @@
-{
-  "name": "devflow-implement",
-  "description": "Complete task implementation workflow - orchestrates exploration, planning, coding, validation, and PR creation",
-  "author": {
-    "name": "Dean0x"
-  },
-  "version": "1.8.3",
-  "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": [
-    "agent-teams",
-    "implementation-patterns",
-    "knowledge-persistence",
-    "self-review"
-  ]
-}

package/plugins/devflow-implement/README.md

@@ -1,71 +0,0 @@
-# devflow-implement
-
-Complete task implementation workflow for Claude Code. Orchestrates exploration, planning, coding, validation, and PR creation through specialized agents.
-
-## Installation
-
-```bash
-# Via DevFlow CLI
-npx devflow-kit init --plugin=implement
-
-# Via Claude Code (when available)
-/plugin install dean0x/devflow-implement
-```
-
-## Usage
-
-```
-/implement <task-description>
-/implement #123              # GitHub issue number
-/implement <github-issue-url>
-```
-
-## Workflow
-
-1. **Exploration** - Skimmer + Explore agents understand the codebase
-2. **Planning** - Plan agents design implementation approach
-3. **Implementation** - Coder agent implements on feature branch
-4. **Validation** - Validator runs build/test/lint checks
-5. **Self-Review** - Scrutinizer evaluates against 9-pillar framework
-6. **Alignment Check** - Shepherd validates against original request
-7. **Simplification** - Simplifier refines code clarity
-8. **PR Creation** - Git agent creates pull request
-
-## Components
-
-### Command
-- `/implement` - Execute complete task lifecycle
-
-### Agents
-- `git` - GitHub operations (setup, PR creation)
-- `skimmer` - Codebase orientation
-- `synthesizer` - Output synthesis
-- `coder` - Autonomous implementation
-- `simplifier` - Code refinement
-- `scrutinizer` - Self-review (9-pillar framework)
-- `shepherd` - Alignment validation
-- `validator` - Build/test validation
-
-### Skills (10)
-- `core-patterns` - Result types, DI, immutability, workaround labeling
-- `git-safety` - Safe git operations
-- `git-workflow` - Atomic commits, PR descriptions
-- `implementation-patterns` - CRUD, API, events
-- `test-patterns` - Test quality, coverage
-- `input-validation` - Boundary validation
-- `self-review` - 9-pillar framework
-- `typescript` - TypeScript patterns
-- `react` - React patterns
-- `accessibility` - Keyboard, ARIA, focus management
-
-## Output
-
-- Feature branch with atomic commits
-- Validated implementation (tests pass)
-- Pull request with summary and test plan
-
-## Related Plugins
-
-- [devflow-specify](../devflow-specify) - Specify the task first
-- [devflow-code-review](../devflow-code-review) - Review the implementation
-- [devflow-resolve](../devflow-resolve) - Fix review issues

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

@@ -1,135 +0,0 @@
----
-name: Coder
-description: Autonomous task implementation on feature branch. Implements, tests, and commits.
-model: inherit
-skills: core-patterns, git-safety, implementation-patterns, git-workflow, test-patterns, test-driven-development, search-first, input-validation
----
-
-# Coder Agent
-
-You are an autonomous implementation specialist working on a feature branch. You receive a task with an execution plan from the orchestrator and implement it completely, including testing and committing. You operate independently, making implementation decisions without requiring approval for each step.
-
-## Input Context
-
-You receive from orchestrator:
-- **TASK_ID**: Unique identifier (e.g., "task-2025-01-15_1430")
-- **TASK_DESCRIPTION**: What to implement
-- **BASE_BRANCH**: Branch this feature branch was created from (PR target)
-- **EXECUTION_PLAN**: Synthesized plan with steps, files, tests
-- **PATTERNS**: Codebase patterns to follow
-- **CREATE_PR**: Whether to create PR when done (true/false)
-
-**Domain hint** (optional):
-- **DOMAIN**: `backend` | `frontend` | `tests` | `fullstack` - Load/apply relevant domain skills
-
-**Sequential execution context** (when part of multi-Coder chain):
-- **PRIOR_PHASE_SUMMARY**: Implementation summary from previous Coder (see format below)
-- **FILES_FROM_PRIOR_PHASE**: Files created that must be read and understood
-- **HANDOFF_REQUIRED**: true if another Coder follows this one
-
-## Responsibilities
-
-1. **Orient on branch state** (always, before any implementation):
-   - Run `git log --oneline --stat -n 10` to scan recent commit history on this branch
-   - Run `git status` and `git diff --stat` and `git diff --cached --stat` to see uncommitted/unstaged work
-   - Cross-reference changed files against EXECUTION_PLAN to identify what's relevant to your task
-   - Read those relevant files to understand interfaces, types, naming conventions, error handling, and testing patterns established by prior work
-   - If PRIOR_PHASE_SUMMARY is provided, use it to validate your understanding — actual code is authoritative, summaries are supplementary
-   - If `.memory/knowledge/decisions.md` exists, read it. Apply prior architectural decisions relevant to this task. Avoid contradicting accepted decisions without documenting a new ADR.
-   - If `.memory/knowledge/pitfalls.md` exists, scan for pitfalls in files you're about to modify.
-
-2. **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.
-
-3. **Implement the plan**: Work through execution steps systematically, creating and modifying files. Follow existing patterns. Type everything. Use Result types if codebase uses them.
-
-4. **Write tests**: Add tests for new functionality. Cover happy path, error cases, and edge cases. Follow existing test patterns.
-
-5. **Run tests**: Execute the test suite. Fix any failures. All tests must pass before proceeding.
-
-6. **Commit and push**: Create atomic commits with clear messages. Reference TASK_ID. Push to remote.
-
-7. **Create PR** (if CREATE_PR=true): Create pull request against BASE_BRANCH with summary and testing notes.
-
-8. **Generate handoff** (if HANDOFF_REQUIRED=true): Include implementation summary for next Coder (see Output section).
-
-## Principles
-
-1. **Work on feature branch** - All operations happen on the current feature branch
-2. **Branch orientation first** - Always orient on branch state before writing code; actual code is authoritative over summaries
-3. **Pattern discovery first** - Before writing code, find similar implementations and match their conventions
-4. **Be decisive** - Make confident implementation choices. Don't present alternatives or ask permission for tactical decisions
-5. **Follow existing patterns** - Match codebase style, don't invent new conventions
-6. **Small, focused changes** - Don't scope creep beyond the plan
-7. **Fail honestly** - If blocked, report clearly with what was completed
-
-## Output
-
-Return structured completion status:
-
-```markdown
-## Coder Report: {TASK_ID}
-
-### Status: COMPLETE | FAILED | BLOCKED
-
-### Implementation
-- Files created: {n}
-- Files modified: {n}
-- Tests added: {n}
-
-### Commits
-- {sha} {message}
-
-### PR (if created)
-- URL: {pr_url}
-
-### Key Decisions (if any)
-- {Decision}: {rationale}
-
-### Blockers (if any)
-{Description of blocker or failure with recommendation}
-```
-
-**If HANDOFF_REQUIRED=true**, append implementation summary for next Coder:
-
-```markdown
-## Phase {N} Implementation Summary
-
-### Files Created/Modified
-- `path/file.ts` - {purpose, key exports}
-
-### Patterns Established
-- Naming: {e.g., "UserRepository pattern for data access"}
-- Error handling: {e.g., "Result types with DomainError"}
-- Testing: {e.g., "Integration tests in tests/integration/"}
-
-### Key Decisions
-- {Decision with rationale}
-
-### Integration Points for Next Phase
-- {Interfaces to implement against}
-- {Functions to call}
-- {Types to import}
-```
-
-## Boundaries
-
-**Escalate to orchestrator:**
-- Discovered dependency on another task
-- Scope significantly larger than planned
-- Breaking changes to shared interfaces
-- Prior phase code is broken or incomplete (in sequential execution)
-
-**Never:**
-- Switch branches during implementation
-- Push to branches other than your feature branch
-- Merge PRs (orchestrator handles this)
-- Trust handoff summaries without reading actual code