devflow-kit 1.8.3 → 2.0.1

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

@@ -1,210 +0,0 @@
-# Rust Extended Patterns
-
-Extended correct patterns for Rust. Reference from main SKILL.md.
-
-## Typestate Pattern
-
-Encode valid state transitions in the type system so invalid sequences don't compile.
-
-```rust
-// States are zero-sized types — no runtime cost
-struct Draft;
-struct Published;
-struct Archived;
-
-struct Article<State> {
-    title: String,
-    body: String,
-    _state: std::marker::PhantomData<State>,
-}
-
-impl Article<Draft> {
-    pub fn new(title: String, body: String) -> Self {
-        Article { title, body, _state: std::marker::PhantomData }
-    }
-
-    pub fn publish(self) -> Article<Published> {
-        Article { title: self.title, body: self.body, _state: std::marker::PhantomData }
-    }
-}
-
-impl Article<Published> {
-    pub fn archive(self) -> Article<Archived> {
-        Article { title: self.title, body: self.body, _state: std::marker::PhantomData }
-    }
-}
-
-// article.archive() on Draft won't compile — transition enforced at compile time
-```
-
----
-
-## Error Handling Hierarchy
-
-Layer errors from specific to general using `thiserror` for libraries and `anyhow` for applications.
-
-```rust
-// Library: precise, typed errors
-#[derive(thiserror::Error, Debug)]
-pub enum RepoError {
-    #[error("entity {entity} with id {id} not found")]
-    NotFound { entity: &'static str, id: String },
-    #[error("duplicate key: {0}")]
-    Duplicate(String),
-    #[error("connection failed")]
-    Connection(#[from] sqlx::Error),
-}
-
-// Application: ergonomic error propagation
-use anyhow::{Context, Result};
-
-fn run() -> Result<()> {
-    let config = load_config()
-        .context("failed to load configuration")?;
-    let db = connect_db(&config.database_url)
-        .context("failed to connect to database")?;
-    serve(db, config.port)
-        .context("server exited with error")
-}
-```
-
----
-
-## Trait Objects vs Generics
-
-### Use Generics for Performance (Monomorphization)
-
-```rust
-fn largest<T: PartialOrd>(list: &[T]) -> Option<&T> {
-    list.iter().reduce(|a, b| if a >= b { a } else { b })
-}
-```
-
-### Use Trait Objects for Heterogeneous Collections
-
-```rust
-trait Handler: Send + Sync {
-    fn handle(&self, request: &Request) -> Response;
-}
-
-struct Router {
-    routes: Vec<Box<dyn Handler>>, // Different concrete types in one Vec
-}
-```
-
-### Decision Guide
-
-| Criteria | Generics | Trait Objects |
-|----------|----------|--------------|
-| Known types at compile time | Yes | No |
-| Heterogeneous collection | No | Yes |
-| Performance-critical | Yes | Acceptable overhead |
-| Binary size concern | Increases | Minimal |
-
----
-
-## Smart Pointers
-
-### Box — Heap Allocation
-
-```rust
-// Recursive types require indirection
-enum List<T> {
-    Cons(T, Box<List<T>>),
-    Nil,
-}
-```
-
-### Rc/Arc — Shared Ownership
-
-```rust
-use std::sync::Arc;
-
-// Shared read-only config across threads
-let config = Arc::new(load_config()?);
-let config_clone = Arc::clone(&config);
-tokio::spawn(async move {
-    use_config(&config_clone).await;
-});
-```
-
-### When to Use Each
-
-| Pointer | Use Case |
-|---------|----------|
-| `Box<T>` | Single owner, heap allocation, recursive types |
-| `Rc<T>` | Multiple owners, single-threaded |
-| `Arc<T>` | Multiple owners, multi-threaded |
-| `Cow<'a, T>` | Clone-on-write, flexible borrowing |
-
----
-
-## From/Into Conversions
-
-```rust
-// Implement From for automatic Into
-impl From<CreateUserRequest> for User {
-    fn from(req: CreateUserRequest) -> Self {
-        User {
-            id: Uuid::new_v4(),
-            name: req.name,
-            email: req.email,
-            created_at: Utc::now(),
-        }
-    }
-}
-
-// Callers get Into for free
-fn save_user(user: impl Into<User>) -> Result<(), DbError> {
-    let user: User = user.into();
-    // ...
-    Ok(())
-}
-```
-
----
-
-## Derive and Trait Best Practices
-
-```rust
-// Derive the standard set for data types
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UserId(String);
-
-// Derive serde for serialization boundaries
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct ApiResponse<T> {
-    pub data: T,
-    pub metadata: Metadata,
-}
-```
-
-### Trait Implementation Order Convention
-
-1. Standard library traits (`Debug`, `Display`, `Clone`, `PartialEq`)
-2. Conversion traits (`From`, `Into`, `TryFrom`)
-3. Iterator traits (`Iterator`, `IntoIterator`)
-4. Serde traits (`Serialize`, `Deserialize`)
-5. Custom traits (domain-specific)
-
----
-
-## Module Organization
-
-```
-src/
-├── lib.rs          # Public API re-exports
-├── error.rs        # Crate-level error types
-├── domain/
-│   ├── mod.rs      # Domain re-exports
-│   ├── user.rs     # User entity and logic
-│   └── order.rs    # Order entity and logic
-├── repo/
-│   ├── mod.rs      # Repository trait definitions
-│   └── postgres.rs # Concrete implementation
-└── api/
-    ├── mod.rs      # Route registration
-    └── handlers.rs # HTTP handlers
-```
-
-Keep `lib.rs` thin — re-export only the public API. Internal modules use `pub(crate)`.

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

@@ -1,191 +0,0 @@
-# Rust Violation Examples
-
-Extended violation patterns for Rust reviews. Reference from main SKILL.md.
-
-## Unwrap Abuse
-
-### Unwrap in Library Code
-
-```rust
-// VIOLATION: Panics on None — caller has no way to handle failure
-pub fn get_username(users: &HashMap<u64, String>, id: u64) -> &str {
-    users.get(&id).unwrap() // Panics if id not found
-}
-
-// VIOLATION: Unwrap on parse without context
-let port: u16 = std::env::var("PORT").unwrap().parse().unwrap();
-```
-
-### Expect Without Useful Message
-
-```rust
-// VIOLATION: Message doesn't help diagnose the problem
-let config = load_config().expect("failed");
-
-// CORRECT: Actionable message
-let config = load_config().expect("failed to load config from config.toml — does file exist?");
-```
-
----
-
-## Unnecessary Cloning
-
-### Clone to Satisfy Borrow Checker
-
-```rust
-// VIOLATION: Cloning to work around borrow issues
-fn process_items(items: &Vec<Item>) {
-    let cloned = items.clone(); // Entire Vec cloned
-    for item in &cloned {
-        println!("{}", item.name);
-    }
-}
-
-// CORRECT: Just borrow
-fn process_items(items: &[Item]) {
-    for item in items {
-        println!("{}", item.name);
-    }
-}
-```
-
-### Clone in Hot Loop
-
-```rust
-// VIOLATION: Allocating on every iteration
-for record in &records {
-    let key = record.id.clone(); // String allocation per iteration
-    map.insert(key, record);
-}
-
-// CORRECT: Borrow or use references
-for record in &records {
-    map.insert(&record.id, record);
-}
-```
-
----
-
-## Stringly-Typed APIs
-
-### String Where Enum Belongs
-
-```rust
-// VIOLATION: Any typo compiles and fails at runtime
-fn set_status(status: &str) {
-    match status {
-        "active" => { /* ... */ }
-        "inactive" => { /* ... */ }
-        _ => panic!("unknown status"), // Runtime failure
-    }
-}
-
-// CORRECT: Compiler enforces valid values
-enum Status { Active, Inactive }
-
-fn set_status(status: Status) {
-    match status {
-        Status::Active => { /* ... */ }
-        Status::Inactive => { /* ... */ }
-    } // Exhaustive — no default needed
-}
-```
-
----
-
-## Unsafe Without Justification
-
-### Bare Unsafe Block
-
-```rust
-// VIOLATION: No safety comment explaining invariants
-unsafe {
-    let ptr = data.as_ptr();
-    std::ptr::copy_nonoverlapping(ptr, dest, len);
-}
-
-// CORRECT: Document why this is safe
-// SAFETY: `data` is guaranteed to be valid for `len` bytes because
-// it was allocated by `Vec::with_capacity(len)` and filled by `read_exact`.
-// `dest` is a valid pointer from `alloc::alloc(layout)` with matching size.
-unsafe {
-    std::ptr::copy_nonoverlapping(data.as_ptr(), dest, len);
-}
-```
-
-### Unnecessary Unsafe
-
-```rust
-// VIOLATION: Using unsafe when safe alternative exists
-unsafe fn get_element(slice: &[u8], index: usize) -> u8 {
-    *slice.get_unchecked(index)
-}
-
-// CORRECT: Safe indexing with bounds check
-fn get_element(slice: &[u8], index: usize) -> Option<u8> {
-    slice.get(index).copied()
-}
-```
-
----
-
-## Ignoring Results
-
-### Discarding Write Errors
-
-```rust
-// VIOLATION: Write failure silently ignored
-let _ = file.write_all(data);
-let _ = file.flush();
-
-// CORRECT: Propagate errors
-file.write_all(data)?;
-file.flush()?;
-```
-
-### Ignoring Lock Poisoning
-
-```rust
-// VIOLATION: Silently ignoring poisoned mutex
-let guard = mutex.lock().unwrap_or_else(|e| e.into_inner());
-
-// CORRECT: Handle or propagate the poison
-let guard = mutex.lock().map_err(|_| AppError::LockPoisoned)?;
-```
-
----
-
-## Concurrency Violations
-
-### Shared Mutable State Without Synchronization
-
-```rust
-// VIOLATION: Data race potential — no synchronization
-static mut COUNTER: u64 = 0;
-
-fn increment() {
-    unsafe { COUNTER += 1; } // Undefined behavior under concurrency
-}
-
-// CORRECT: Use atomic or mutex
-use std::sync::atomic::{AtomicU64, Ordering};
-static COUNTER: AtomicU64 = AtomicU64::new(0);
-
-fn increment() {
-    COUNTER.fetch_add(1, Ordering::Relaxed);
-}
-```
-
-### Blocking in Async Context
-
-```rust
-// VIOLATION: Blocks the async runtime thread
-async fn read_file(path: &str) -> Result<String, io::Error> {
-    std::fs::read_to_string(path) // Blocking call in async fn
-}
-
-// CORRECT: Use async file I/O or spawn_blocking
-async fn read_file(path: &str) -> Result<String, io::Error> {
-    tokio::fs::read_to_string(path).await
-}
-```

package/plugins/devflow-self-review/.claude-plugin/plugin.json

@@ -1,26 +0,0 @@
-{
-  "name": "devflow-self-review",
-  "description": "Self-review workflow: Simplifier + Scrutinizer for code quality",
-  "author": {
-    "name": "Dean0x"
-  },
-  "version": "1.8.3",
-  "homepage": "https://github.com/dean0x/devflow",
-  "repository": "https://github.com/dean0x/devflow",
-  "license": "MIT",
-  "keywords": [
-    "self-review",
-    "simplifier",
-    "scrutinizer",
-    "quality"
-  ],
-  "agents": [
-    "simplifier",
-    "scrutinizer",
-    "validator"
-  ],
-  "skills": [
-    "self-review",
-    "core-patterns"
-  ]
-}

package/plugins/devflow-self-review/README.md

@@ -1,38 +0,0 @@
-# DevFlow Self-Review Plugin
-
-Self-review workflow that runs Simplifier and Scrutinizer sequentially on your code changes.
-
-## Installation
-
-```bash
-npx devflow-kit init --plugin=self-review
-```
-
-## Usage
-
-```bash
-# Auto-detect changed files
-/self-review
-
-# Review specific files
-/self-review src/api/auth.ts src/utils/crypto.ts
-```
-
-## What It Does
-
-1. **Simplifier** - Refines code for clarity, consistency, and maintainability
-2. **Scrutinizer** - Evaluates against 9-pillar quality framework, fixes issues
-
-## 9-Pillar Framework
-
-| Priority | Pillars | Action |
-|----------|---------|--------|
-| P0 | Design, Functionality, Security | Must fix |
-| P1 | Complexity, Error Handling, Tests | Should fix |
-| P2 | Naming, Consistency, Documentation | Suggestions |
-
-## When to Use
-
-- After implementing a feature, before creating PR
-- After resolving review issues
-- For periodic code quality checks on recent changes

package/plugins/devflow-self-review/agents/scrutinizer.md

@@ -1,82 +0,0 @@
----
-name: Scrutinizer
-description: Self-review agent that evaluates and fixes implementation issues using 9-pillar framework. Runs in fresh context after Coder completes.
-model: inherit
-skills: self-review, core-patterns
----
-
-# Scrutinizer Agent
-
-You are a meticulous self-review specialist. You evaluate implementations against the 9-pillar quality framework and fix issues before handoff to Simplifier. You run in a fresh context after Coder completes, ensuring adequate resources for thorough review and fixes.
-
-## Input Context
-
-You receive from orchestrator:
-- **TASK_DESCRIPTION**: What was implemented
-- **FILES_CHANGED**: List of modified files from Coder output
-
-## Responsibilities
-
-1. **Gather changes**: Read all files in FILES_CHANGED to understand the implementation.
-
-2. **Evaluate P0 pillars** (Design, Functionality, Security): These MUST pass. Fix all issues found.
-
-3. **Detect stubs and wiring gaps**: Check for placeholder implementations that compile but don't deliver real functionality. See `references/stub-detection.md` for patterns. Flag as P0-Functionality issues.
-
-4. **Evaluate P1 pillars** (Complexity, Error Handling, Tests): These SHOULD pass. Fix all issues found.
-
-5. **Evaluate P2 pillars** (Naming, Consistency, Documentation): Report as suggestions. Fix if straightforward.
-
-6. **Commit fixes**: If any changes were made, create a commit with message "fix: address self-review issues".
-
-7. **Report status**: Return structured report with pillar evaluations and changes made.
-
-## Principles
-
-1. **Fix, don't report** - Self-review means fixing issues, not generating reports
-2. **Fresh context advantage** - Use your full context for thorough evaluation
-3. **Pillar priority** - P0 issues block, P1 issues should be fixed, P2 are suggestions
-4. **Minimal changes** - Fix the issue, don't refactor surrounding code
-5. **Honest assessment** - If P0 issue is unfixable, report BLOCKED immediately
-
-## Output
-
-Return structured completion status:
-
-```markdown
-## Self-Review Report
-
-### Status: PASS | BLOCKED
-
-### P0 Pillars
-- Design: PASS | FIXED (description) | BLOCKED (reason)
-- Functionality: PASS | FIXED (description) | BLOCKED (reason)
-- Security: PASS | FIXED (description) | BLOCKED (reason)
-
-### P1 Pillars
-- Complexity: PASS | FIXED (description)
-- Error Handling: PASS | FIXED (description)
-- Tests: PASS | FIXED (description)
-
-### P2 Suggestions
-- {pillar}: {suggestion with file:line reference}
-
-### Files Modified
-- {file} ({change description})
-
-### Commits Created
-- {sha} fix: address self-review issues
-```
-
-## Boundaries
-
-**Escalate to orchestrator (BLOCKED):**
-- P0 issue requiring architectural change beyond scope
-- Security vulnerability that needs design reconsideration
-- Functionality issue that invalidates the implementation approach
-
-**Handle autonomously:**
-- All fixable P0 and P1 issues
-- P2 improvements that are straightforward
-- Adding missing tests for new code
-- Fixing error handling gaps

package/plugins/devflow-self-review/agents/simplifier.md

@@ -1,102 +0,0 @@
----
-name: Simplifier
-description: Simplifies and refines code for clarity, consistency, and maintainability while preserving all functionality. Focuses on recently modified code unless instructed otherwise.
-skills: core-patterns
-model: inherit
----
-
-# Simplifier Agent
-
-You are an expert code simplification specialist focused on enhancing code clarity, consistency, and maintainability while preserving exact functionality. Your expertise lies in applying project-specific best practices to simplify and improve code without altering its behavior. You prioritize readable, explicit code over overly compact solutions. This is a balance that you have mastered as a result of your years as an expert software engineer.
-
-## Input Context
-
-You receive from orchestrator:
-- **TASK_DESCRIPTION**: What was implemented
-- **FILES_CHANGED**: List of modified files from Coder output (optional)
-
-## Responsibilities
-
-Analyze recently modified code and apply refinements that:
-
-1. **Preserve Functionality**: Never change what the code does - only how it does it. All original features, outputs, and behaviors must remain intact.
-
-2. **Apply Project Standards**: Follow the established coding standards from CLAUDE.md including:
-
-   - Use ES modules with proper import sorting and extensions
-   - Prefer `function` keyword over arrow functions
-   - Use explicit return type annotations for top-level functions
-   - Follow proper React component patterns with explicit Props types
-   - Use proper error handling patterns (avoid try/catch when possible)
-   - Maintain consistent naming conventions
-
-3. **Remove Slop**: Detect and remove these categories:
-
-   | Category | Pattern |
-   |----------|---------|
-   | Language-behavior tests | Tests verifying built-in language features work as documented |
-   | Redundant type checks | Runtime checks for types TypeScript already enforces |
-   | Over-defensive handling | try/catch around code that cannot throw |
-   | Debug remnants | console.log, debugger, alert() left behind |
-   | Commented-out code | Dead code preserved in comments |
-   | Unused imports | Imports not referenced anywhere in file |
-   | Verbose names | Unnecessarily long names (`currentUserDataObject` → `user`) |
-   | Unnecessary intermediates | Variables used once, immediately after assignment |
-
-4. **Enhance Clarity**: Simplify code structure by:
-
-   - Reducing unnecessary nesting (early returns, guard clauses)
-   - Consolidating related logic
-   - Avoiding nested ternary operators — prefer switch or if/else
-   - Choosing clarity over brevity — explicit code beats compact code
-
-5. **Maintain Balance**: Avoid over-simplification that could:
-
-   - Create overly clever solutions that are hard to understand
-   - Combine too many concerns into single functions or components
-   - Remove helpful abstractions that improve code organization
-   - Make the code harder to debug or extend
-
-6. **Focus Scope**: Only refine code that has been recently modified or touched in the current session, unless explicitly instructed to review a broader scope.
-
-Your refinement process:
-
-1. Identify the recently modified code sections
-2. Analyze for slop categories and clarity improvements
-3. Apply project-specific best practices and coding standards
-4. Ensure all functionality remains unchanged
-5. Verify the refined code is simpler and more maintainable
-6. Document only significant changes that affect understanding
-
-You operate autonomously and proactively, refining code immediately after it's written or modified without requiring explicit requests. Your goal is to ensure all code meets the highest standards of elegance and maintainability while preserving its complete functionality.
-
-## Output
-
-Return structured completion status:
-
-```markdown
-## Simplification Report
-
-### Changes Applied
-- {file}: {description of simplification}
-
-### Changes Skipped
-- {reason not simplified — would change behavior / already clean}
-
-### Files Modified
-- {file} ({change description})
-```
-
-## Boundaries
-
-**Escalate to orchestrator:**
-- Changes that would alter observable behavior or break tests
-- Simplifications requiring new dependencies or architectural changes
-- Files outside the recently modified scope (unless instructed)
-
-**Handle autonomously:**
-- Slop removal (all 8 categories)
-- Naming improvements, nesting reduction
-- Import sorting and organization
-- Redundant abstraction elimination
-- Comment cleanup (remove obvious, keep non-obvious)