devflow-kit 1.8.2 → 2.0.0

package/plugins/devflow-implement/skills/self-review/SKILL.md

@@ -1,149 +0,0 @@
----
-name: self-review
-description: This skill should be used when evaluating implementation quality before submission, checking correctness, security, and simplicity.
-user-invocable: false
-allowed-tools: Read, Grep, Glob, Edit, Write, Bash
----
-
-# Self-Review Framework
-
-Systematic self-review for the Scrutinizer agent. Evaluate implementation against 9 pillars. **Fix issues, don't just report them.**
-
-Based on [Google Engineering Practices](https://google.github.io/eng-practices/review/reviewer/looking-for.html).
-
-## Iron Law
-
-> **FIX BEFORE RETURNING**
->
-> Self-review is not a report generator. It's a quality gate. If you find a P0 or P1 issue,
-> you fix it. You only return when all critical issues are resolved. Pride in craftsmanship.
-
----
-
-## The 9 Pillars
-
-| Priority | Action | Pillars |
-|----------|--------|---------|
-| **P0** | MUST fix | Design, Functionality, Security |
-| **P1** | SHOULD fix | Complexity, Error Handling, Tests |
-| **P2** | FIX if time | Naming, Consistency, Documentation |
-
-### P0 - Design
-Does the implementation fit the architecture? Follows existing patterns, respects layer boundaries, dependencies injected.
-
-### P0 - Functionality
-Does the code work? Happy path, edge cases (null, empty, boundary), no race conditions.
-
-### P0 - Security
-Any vulnerabilities? No injection, input validated, no hardcoded secrets, auth checked.
-
-### P1 - Complexity
-Understandable in 5 minutes? Functions < 50 lines, nesting < 4 levels, no magic numbers.
-
-### P1 - Error Handling
-Errors handled explicitly? No swallowed exceptions, helpful messages, resources cleaned up.
-
-### P1 - Tests
-New code tested? Covers happy path, errors, edges. Tests behavior, not implementation.
-
-### P2 - Naming
-Names clear and descriptive? No cryptic abbreviations, consistent style.
-
-### P2 - Consistency
-Matches existing patterns? Same style, same conventions, no unnecessary divergence.
-
-### P2 - Documentation
-Will others understand? Complex logic commented, public APIs documented, no outdated comments.
-
----
-
-## Quick Examples
-
-### Design Red Flag
-```typescript
-// BAD: Direct DB in controller (violates layers)
-class UserController {
-  async getUser(req, res) {
-    const user = await db.query('SELECT * FROM users WHERE id = ?', [req.params.id]);
-  }
-}
-```
-
-### Security Red Flag
-```typescript
-// BAD: SQL injection
-const query = `SELECT * FROM users WHERE email = '${email}'`;
-
-// BAD: Missing auth
-app.delete('/api/users/:id', async (req, res) => {
-  await deleteUser(req.params.id);  // No auth check!
-});
-```
-
----
-
-## Self-Review Process
-
-### Step 1: Gather Changes
-```bash
-git diff --name-only HEAD~1
-git diff HEAD~1
-```
-
-### Step 2: Evaluate P0 Pillars
-Check Design, Functionality, Security. If issues found and fixable, fix immediately. If unfixable, STOP and report blocker.
-
-### Step 3: Evaluate P1 Pillars
-Check Complexity, Error Handling, Tests. Fix issues found.
-
-### Step 4: Evaluate P2 Pillars
-Check Naming, Consistency, Documentation. Fix if time permits.
-
-### Step 5: Generate Report
-Document status of each pillar, fixes applied, and overall readiness.
-
----
-
-## Output Format
-
-```markdown
-## Self-Review Report
-
-### P0 Pillars
-- Design: PASS/FIXED
-- Functionality: PASS/FIXED
-- Security: PASS/FIXED
-
-### P1 Pillars
-- Complexity: PASS/FIXED
-- Error Handling: PASS/FIXED
-- Tests: PASS/FIXED
-
-### P2 Pillars
-- Naming: PASS/FIXED/SKIP
-- Consistency: PASS/FIXED/SKIP
-- Documentation: PASS/FIXED/SKIP
-
-### Summary
-Issues Found: {n}, Fixed: {n}
-Status: READY / BLOCKED
-```
-
----
-
-## Extended References
-
-For detailed checklists, examples, and red flags for each pillar:
-- See `references/pillars.md`
-
-For complete report templates and examples:
-- See `references/report-template.md`
-
----
-
-## Integration
-
-Used by:
-- **Scrutinizer agent**: Dedicated self-review in fresh context after Coder completes
-
-The self-review ensures implementations meet quality standards before external review, catching issues early.

package/plugins/devflow-implement/skills/self-review/references/stub-detection.md

@@ -1,135 +0,0 @@
-# Stub Detection Patterns
-
-Placeholder implementations that compile but don't deliver real functionality. Flag as **P0-Functionality** issues.
-
-Cross-reference: `core-patterns/references/code-smell-violations.md` covers hardcoded data and fake functionality labeling. This file focuses on structural stub patterns.
-
----
-
-## 1. Component Stubs
-
-Render nothing meaningful or return placeholder markup.
-
-```tsx
-// STUB — returns static text, no real rendering
-function UserProfile({ userId }: Props) {
-  return <div>Name</div>;
-}
-
-// REAL — fetches and renders actual data
-function UserProfile({ userId }: Props) {
-  const user = useUser(userId);
-  if (!user) return <Skeleton />;
-  return <div><h2>{user.name}</h2><p>{user.email}</p></div>;
-}
-```
-
-**Patterns to flag:**
-- `return null` / `return <></>` in components that should render content
-- Empty function bodies (`{}`) for handlers or lifecycle methods
-- Components returning only hardcoded strings with no data binding
-
----
-
-## 2. API / Service Stubs
-
-Functions that exist in signature but throw, return hardcoded values, or do nothing.
-
-```typescript
-// STUB — throws instead of implementing
-async function createOrder(items: CartItem[]): Promise<Order> {
-  throw new Error("TODO: implement");
-}
-
-// STUB — hardcoded return, no real logic
-async function getUser(id: string): Promise<User> {
-  return { id, name: "Test User", email: "test@test.com" };
-}
-
-// REAL — actual implementation
-async function createOrder(items: CartItem[]): Promise<Result<Order, OrderError>> {
-  const validated = validateItems(items);
-  if (!validated.ok) return validated;
-  const order = await db.orders.create({ items: validated.value });
-  await queue.publish("order.created", order);
-  return { ok: true, value: order };
-}
-```
-
-**Patterns to flag:**
-- `throw new Error("TODO")` / `throw new Error("Not implemented")`
-- Functions returning hardcoded objects (no DB/API/computation)
-- `"Not implemented"` strings in response bodies
-- Empty async functions (`async function foo() {}`)
-
----
-
-## 3. Hook / Effect Stubs
-
-State and effects declared but not wired to behavior.
-
-```typescript
-// STUB — effect does nothing
-useEffect(() => {}, [userId]);
-
-// STUB — state declared, setter never called
-const [items, setItems] = useState<Item[]>([]);
-// ... setItems never appears in the component
-
-// STUB — custom hook returns static value
-function usePermissions(): Permissions {
-  return { canEdit: true, canDelete: false };
-}
-
-// REAL — custom hook with actual logic
-function usePermissions(): Permissions {
-  const { user } = useAuth();
-  const { data } = useQuery(["permissions", user.role], fetchPermissions);
-  return data ?? DEFAULT_PERMISSIONS;
-}
-```
-
-**Patterns to flag:**
-- `useEffect(() => {}, [...])` — empty effect body
-- `useState` where the setter is never called in the component
-- Custom hooks returning static/hardcoded values
-- `useMemo`/`useCallback` wrapping static values
-
----
-
-## 4. Wiring Gaps
-
-Individual pieces exist but aren't connected to the running application. **Highest-value detection** — these pass compilation and individual tests but the feature doesn't work end-to-end.
-
-```typescript
-// GAP — fetch without await (result discarded)
-function loadDashboard() {
-  fetchMetrics(); // Promise floats, never awaited
-  return <Dashboard />;
-}
-
-// GAP — state declared but never rendered
-const [error, setError] = useState<string | null>(null);
-// ... error never appears in JSX
-
-// GAP — handler defined but not bound
-function handleSubmit(data: FormData) { /* real logic */ }
-// ... <form onSubmit={handleSubmit}> never appears
-
-// GAP — route defined with no-op handler
-app.post("/api/orders", (_req, res) => {
-  res.status(200).json({ ok: true });
-});
-
-// GAP — env var read but unused
-const API_KEY = process.env.STRIPE_API_KEY;
-// ... API_KEY never passed to any client or fetch call
-```
-
-**Patterns to flag:**
-- `fetch`/`axios`/API call without `await` or `.then` (result discarded)
-- State variable (`useState`, `useRef`) never rendered or read in output
-- Event handler defined but not bound to any element/listener
-- Route/endpoint registered with empty or no-op handler
-- Environment variable or config read but never used downstream
-- Import used only in type position but imported as value (in non-type-only import)

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

@@ -1,21 +0,0 @@
-{
-  "name": "devflow-java",
-  "description": "Java language patterns - records, sealed classes, composition, modern Java features",
-  "author": {
-    "name": "Dean0x"
-  },
-  "version": "1.8.2",
-  "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

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