@wipal/agent-team 1.0.3 → 1.1.0

package/.claude/commands/utils/learn.md

@@ -0,0 +1,142 @@
+---
+name: learn
+description: Quickly capture a learning or pattern
+---
+
+# Learn Command
+
+## Usage
+```
+/learn <type> <content>
+```
+
+## Types
+
+| Type | Description | Example |
+|------|-------------|---------|
+| `pattern` | A reusable pattern to remember | `/learn pattern Always use useCallback for handlers passed to children` |
+| `pitfall` | Something to avoid | `/learn pitfall Don't use useEffect for derived state` |
+| `rule` | A rule to follow | `/learn rule Always check Context7 before using new APIs` |
+| `tip` | A helpful tip | `/learn tip Use React DevTools Profiler for performance issues` |
+| `correction` | Something you were corrected on | `/learn correction User said to always handle loading states` |
+
+## Examples
+
+### Capture a pattern
+```
+/learn pattern Repository pattern with Prisma
+```
+
+Output:
+```
+✅ Pattern captured
+
+**Pattern:** Repository pattern with Prisma
+**Added to:** knowledge.md
+
+Would you like to add a code example? [y/n]
+```
+
+### Capture a pitfall
+```
+/learn pitfall N+1 queries in OrderService.getOrders
+```
+
+Output:
+```
+✅ Pitfall captured
+
+**Pitfall:** N+1 queries in OrderService.getOrders
+**Added to:** knowledge.md
+**Lesson:** Use Prisma include for relations instead of separate queries
+
+Example fix:
+```typescript
+// ❌ Bad
+for (const order of orders) {
+  order.items = await this.getItems(order.id);
+}
+
+// ✅ Good
+const orders = await this.prisma.order.findMany({
+  include: { items: true }
+});
+```
+```
+
+### Capture a correction
+```
+/learn correction User corrected: Always add loading state for async operations
+```
+
+Output:
+```
+✅ Correction captured
+
+**Correction:** Always add loading state for async operations
+**Added to:** lessons.md
+**Rule generated:** "Add loading state before any async operation"
+
+This rule will be applied in future tasks.
+```
+
+## Quick Capture
+
+For quick capture without type:
+```
+/learn Always validate user input on the server side
+```
+
+Output:
+```
+What type is this?
+1. Pattern
+2. Pitfall
+3. Rule
+4. Tip
+
+Select [1-4]:
+```
+
+## Reviewing Learnings
+
+To see all captured learnings:
+```
+/learn --review
+```
+
+Output:
+```
+📚 Learnings for: current-agent
+
+## Patterns (5)
+1. Repository pattern with Prisma
+2. Form validation with Zod + react-hook-form
+3. Error handling with custom exceptions
+...
+
+## Pitfalls (3)
+1. N+1 queries
+2. Missing loading states
+...
+
+## Rules (4)
+1. Always check Context7 first
+2. Handle loading/error states
+...
+
+## Recent Corrections (2)
+1. 2025-02-25: Add loading state for async
+2. 2025-02-24: Use proper TypeScript types
+
+---
+Total: 14 learnings
+```
+
+## Integration
+
+Learnings are:
+- Stored in `knowledge.md`
+- Synced via `/sync` command
+- Reviewed at session start
+- Promoted to skills over time

package/.claude/commands/utils/retrospect.md

@@ -0,0 +1,62 @@
+---
+name: retrospect
+description: Run self-learning retrospect on current session
+---
+
+# Retrospect Command
+
+## Usage
+```
+/retrospect [options]
+```
+
+## Options
+- `--deep` - Deep analysis of all changes
+- `--agent <name>` - Retrospect for specific agent
+- `--all` - Run for all agents
+
+## What It Does
+
+1. **Analyzes** changes made in session
+2. **Extracts** patterns and learnings
+3. **Updates** knowledge.md
+4. **Updates** lessons.md
+5. **Suggests** rule updates
+
+## Output
+
+```
+═══════════════════════════════════════════════════════════════
+🧠 RETROSPECT: Session Analysis
+═══════════════════════════════════════════════════════════════
+
+📊 Session Summary:
+- Files changed: 5
+- Lines added: 234
+- Lines removed: 45
+
+✅ Patterns Found:
+1. Repository Pattern used correctly
+2. DTO validation with Zod
+3. Error handling with custom exceptions
+
+⚠️ Anti-patterns Detected:
+1. N+1 query in getOrders() - Fixed
+2. Missing loading state - Added
+
+📝 Knowledge Updates:
+- Added: Repository Pattern example
+- Added: Error handling pattern
+- Updated: Testing approach
+
+📄 Files Updated:
+- knowledge.md (2 additions)
+- lessons.md (1 lesson)
+
+Approve changes? [y/n]:
+```
+
+## Integration
+- Works with `retrospect-work` skill
+- Updates agent's knowledge base
+- Can sync to related agents

package/.claude/commands/utils/switch.md

@@ -0,0 +1,113 @@
+---
+name: switch
+description: Switch to a different agent role
+---
+
+# Switch Agent Command
+
+## Usage
+```
+/switch <agent-name>
+```
+
+## What It Does
+
+Switches the current conversation to use a different agent configuration.
+
+1. **Reads** the target agent's CLAUDE.md
+2. **Loads** the agent's knowledge base
+3. **Applies** role-specific rules
+4. **Prepares** context for the new role
+
+## Examples
+
+### Switch to frontend developer
+```
+/switch fe-payment
+```
+
+Output:
+```
+✅ Switched to agent: fe-payment
+Role: Frontend Developer
+Variants: react, tailwind, zustand
+
+Available skills:
+- frontend-design
+- react-patterns
+- git-automation
+- code-review
+
+Ready to work on frontend tasks!
+```
+
+### Switch to backend developer
+```
+/switch auth-api
+```
+
+Output:
+```
+✅ Switched to agent: auth-api
+Role: Backend Developer
+Variants: nestjs, prisma, postgresql
+
+Available skills:
+- api-design
+- nestjs-patterns
+- database-design
+- security
+
+Ready to work on backend tasks!
+```
+
+### Switch to tech lead
+```
+/switch lead
+```
+
+Output:
+```
+✅ Switched to agent: lead
+Role: Technical Lead
+Model: Claude Opus 4 (with thinking mode)
+
+Responsibilities:
+- Architecture decisions
+- Code review
+- Technical strategy
+
+Ready to review and guide!
+```
+
+## Listing Available Agents
+
+If you don't know the agent name:
+```
+/switch
+```
+
+Output:
+```
+Available agents:
+
+┌─────────────────┬─────────┬──────────────────────────────┐
+│ Agent           │ Role    │ Variants                     │
+├─────────────────┼─────────┼──────────────────────────────┤
+│ fe-payment      │ dev-fe  │ react, tailwind, zustand     │
+│ fe-admin        │ dev-fe  │ vue, tailwind, pinia         │
+│ auth-api        │ dev-be  │ nestjs, prisma               │
+│ lead            │ tech-lead│ -                           │
+│ tester          │ qa      │ playwright                   │
+└─────────────────┴─────────┴──────────────────────────────┘
+
+Usage: /switch <agent-name>
+```
+
+## After Switching
+
+The agent will:
+- Load role-specific knowledge
+- Apply relevant rules
+- Be ready for tasks in that domain
+- Remember previous context when switching back

package/.claude/commands/utils/sync.md

@@ -0,0 +1,183 @@
+---
+name: sync
+description: Sync knowledge between agents
+---
+
+# Sync Command
+
+## Usage
+```
+/sync <from-agent> <to-agent>
+/sync <from-agent> --to-role <role>
+/sync --all
+```
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `<from-agent>` | Source agent to sync from |
+| `<to-agent>` | Target agent to sync to |
+| `--to-role <role>` | Sync to all agents of the same role |
+| `--all` | Sync across all agents |
+| `--patterns` | Only sync patterns |
+| `--pitfalls` | Only sync pitfalls |
+| `--rules` | Only sync rules |
+
+## Examples
+
+### Sync between two agents
+```
+/sync payment-fe admin-fe
+```
+
+Output:
+```
+═══════════════════════════════════════════════════════════════
+🔄 SYNCING KNOWLEDGE
+═══════════════════════════════════════════════════════════════
+
+From: payment-fe (dev-fe + react)
+To: admin-fe (dev-fe + vue)
+
+📚 Patterns to sync:
+1. Form validation with Zod
+2. Error handling pattern
+3. API response format
+
+⚠️ Pitfalls to sync:
+1. N+1 queries in user list
+
+📝 Syncing...
+✅ Added 3 patterns to admin-fe
+✅ Added 1 pitfall to admin-fe
+
+Sync complete? [y/n]:
+═══════════════════════════════════════════════════════════════
+```
+
+### Sync to all agents of same role
+```
+/sync payment-fe --to-role dev-fe
+```
+
+Output:
+```
+═══════════════════════════════════════════════════════════════
+🔄 SYNCING KNOWLEDGE TO ROLE: dev-fe
+═══════════════════════════════════════════════════════════════
+
+From: payment-fe
+
+Target agents:
+├── admin-fe (will receive 3 patterns)
+├── dashboard-fe (will receive 3 patterns)
+└── settings-fe (will receive 3 patterns)
+
+Patterns to sync:
+1. Form validation with Zod
+2. Error handling pattern
+3. API response format
+
+Sync to all 3 agents? [y/n]:
+```
+
+### Sync only patterns
+```
+/sync payment-fe admin-fe --patterns
+```
+
+### Sync across all agents
+```
+/sync --all
+```
+
+Output:
+```
+═══════════════════════════════════════════════════════════════
+🔄 SYNCING ACROSS ALL AGENTS
+═══════════════════════════════════════════════════════════════
+
+Analyzing knowledge bases...
+
+📚 Universal Patterns (apply to all):
+1. Always handle loading states
+2. Always handle error states
+3. Use Context7 before implementing
+
+🔧 Role-Specific Patterns (sync within roles):
+- dev-fe: 5 patterns shared
+- dev-be: 4 patterns shared
+
+Sync universal patterns to all agents? [y/n]:
+```
+
+## What Gets Synced
+
+### Patterns
+Reusable code patterns and approaches
+```markdown
+## Pattern: Form Validation with Zod
+Use Zod schemas for type-safe validation...
+
+**Code:**
+\`\`\`typescript
+const schema = z.object({...});
+\`\`\`
+```
+
+### Pitfalls
+Common mistakes to avoid
+```markdown
+## Pitfall: N+1 Queries
+Avoid fetching related data in loops...
+```
+
+### Rules
+Learned rules from corrections
+```markdown
+## Rule: Always Check Context7
+Before using any API, check Context7 for latest docs...
+```
+
+## What Doesn't Get Synced
+
+- Project-specific context
+- Sensitive information
+- Temporary notes
+- User corrections (only lessons extracted)
+
+## Sync Strategy
+
+### When to Sync
+- After completing a feature with reusable patterns
+- After fixing a bug that could affect other agents
+- After learning a new best practice
+- At end of day/week
+
+### What to Sync
+| Type | Sync Across Roles | Sync Within Role |
+|------|-------------------|------------------|
+| Patterns | Universal only | All |
+| Pitfalls | Universal only | All |
+| Rules | All | All |
+| Context | Never | Never |
+
+## Integration
+
+Sync works with:
+- `/retrospect` - Extract patterns before syncing
+- `/learn` - Add new patterns to sync
+- `./agent.sh sync` - CLI version
+
+## CLI Equivalent
+```bash
+# Sync between agents
+./agent.sh sync payment-fe admin-fe
+
+# Sync to role
+./agent.sh sync payment-fe --to-role dev-fe
+
+# Sync all
+./agent.sh sync --all
+```

package/.claude/rules/common/general-rules.md

@@ -67,6 +67,12 @@
 - Don't refactor unrelated code
 - Keep PRs focused
 
+### Demand Elegance (Balanced)
+- For non-trivial changes: pause and ask "is there a more elegant way?"
+- If a fix feels hacky: "Knowing everything I know now, implement the elegant solution"
+- Skip this for simple, obvious fixes - don't over-engineer
+- Challenge your own work before presenting it
+
 ---
 
 ## Verification Protocol