feat: Integrate MCP servers for enhanced capabilities

.claude/commands/brainstorm.md

@@ -180,6 +180,36 @@ After design is complete:
 | 4 | 8-10 | Comprehensive |
 | 5 | 10+ | Exhaustive, all angles |
 
+## MCP Integration
+
+This command leverages MCP servers for enhanced brainstorming:
+
+### Sequential Thinking - Structured Exploration (Primary)
+```
+ALWAYS use Sequential Thinking for brainstorming:
+- Explore design options systematically
+- Track pros/cons for each approach
+- Revise conclusions based on user feedback
+- Build confidence in final design incrementally
+```
+
+### Memory - Design Persistence
+```
+Store design decisions for continuity:
+- Create entities for design concepts
+- Store user preferences and constraints
+- Recall previous design patterns
+- Build knowledge graph of architecture decisions
+```
+
+### Context7 - Technology Options
+```
+When exploring technology choices:
+- Fetch current documentation for options
+- Compare library capabilities accurately
+- Understand trade-offs with real data
+```
+
 ## When NOT to Use
 
 - Clear "mechanical" processes with known implementation

.claude/commands/feature.md

@@ -200,6 +200,47 @@ git diff --staged
 /feature --format=concise "add logging utility"
 ```
 
+## MCP Integration
+
+This command leverages MCP servers for enhanced capabilities:
+
+### Context7 - Library Documentation
+When researching unfamiliar libraries or frameworks:
+```
+Use Context7's resolve-library-id and get-library-docs tools to fetch
+current documentation for any libraries involved in the feature.
+```
+
+### Sequential Thinking - Structured Planning
+For complex feature breakdowns:
+```
+Use Sequential Thinking's sequentialthinking tool for step-by-step
+analysis when decomposing requirements or designing architecture.
+```
+
+### Memory - Context Persistence
+Store and recall project context:
+```
+- Store architectural decisions made during planning
+- Recall user preferences from previous sessions
+- Remember patterns used in similar features
+```
+
+### Filesystem - File Operations
+For creating and modifying files:
+```
+- Use directory_tree to understand project structure
+- Use search_files to find related implementations
+- Use read_file and write_file for file operations
+```
+
+### Playwright - E2E Testing
+For features with UI components:
+```
+Use Playwright for browser-based E2E testing of the implemented feature.
+Validate user flows and interactions in real browser environment.
+```
+
 <!-- CUSTOMIZATION POINT -->
 ## Variations
 

.claude/commands/fix.md

@@ -262,6 +262,53 @@ for item in items:
 | `performance` | Speed, memory, efficiency |
 | `reliability` | Error handling, edge cases |
 
+## MCP Integration
+
+This command leverages MCP servers for enhanced debugging:
+
+### Sequential Thinking - Root Cause Analysis (Primary)
+```
+ALWAYS use Sequential Thinking for debugging:
+- Trace execution path step-by-step
+- Form and test hypotheses systematically
+- Track confidence in each potential cause
+- Revise understanding as evidence emerges
+```
+
+### Memory - Bug Context
+```
+Store and recall debugging context:
+- Remember similar bugs from previous sessions
+- Recall fix patterns that worked before
+- Store root cause analysis for future reference
+- Create relations between bugs and affected components
+```
+
+### Playwright - Browser Testing
+```
+For UI/frontend bugs:
+- Reproduce the bug in browser environment
+- Test fix across different browsers
+- Verify visual regressions are resolved
+- Automate regression test for the fix
+```
+
+### Context7 - Library Issues
+```
+When debugging library-related issues:
+- Fetch current documentation for correct usage
+- Check for known issues or breaking changes
+- Find correct patterns and examples
+```
+
+### Filesystem - Code Search
+```
+For tracing bug across codebase:
+- Use search_files to find related code
+- Use read_file to examine suspicious areas
+- Track changes with file history
+```
+
 <!-- CUSTOMIZATION POINT -->
 ## Variations
 

.claude/commands/index.md

@@ -120,3 +120,25 @@ After generating the index, inform the user:
 2. Number of files indexed
 3. Key components discovered
 4. Suggest using `/load` to load specific components into context
+
+## MCP Integration
+
+This command leverages MCP servers for enhanced indexing:
+
+### Filesystem - Project Scanning (Primary)
+```
+ALWAYS use Filesystem for project scanning:
+- Use directory_tree for full structure view
+- Use list_directory for targeted exploration
+- Use search_files to find specific patterns
+- Use get_file_info for file metadata
+```
+
+### Memory - Project Knowledge
+```
+Store project structure in knowledge graph:
+- Create entities for key modules
+- Store component relationships
+- Recall structure in future sessions
+- Build project understanding over time
+```

.claude/commands/plan.md

@@ -285,6 +285,44 @@ Use `/execute-plan [plan-file]` for subagent-driven execution with code review g
 | `deep-research` | Complex features needing investigation |
 | `implementation` | Quick plans for clear tasks |
 
+## MCP Integration
+
+This command leverages MCP servers for enhanced planning:
+
+### Sequential Thinking - Structured Planning (Primary)
+```
+ALWAYS use Sequential Thinking for task decomposition:
+- Break complex tasks into logical thought sequences
+- Track dependencies between steps
+- Revise plan as understanding deepens
+- Use for risk identification and mitigation planning
+```
+
+### Memory - Decision Persistence
+```
+Store and recall planning context:
+- Remember decisions from previous planning sessions
+- Recall user preferences for task sizing
+- Store architectural patterns for reuse
+- Create entities for major features/components
+```
+
+### Context7 - Technology Research
+```
+When planning involves unfamiliar technologies:
+- Fetch current documentation for accurate estimates
+- Understand API patterns before estimating complexity
+- Identify potential integration challenges
+```
+
+### Filesystem - Codebase Analysis
+```
+For accurate file identification:
+- Use directory_tree to understand project structure
+- Use search_files to find existing patterns
+- Identify files to create vs modify
+```
+
 <!-- CUSTOMIZATION POINT -->
 ## Variations
 

.claude/commands/research.md

@@ -61,6 +61,34 @@ Research: **$ARGUMENTS**
 | 4 | Comprehensive with trade-offs |
 | 5 | Exhaustive with citations |
 
+## MCP Integration
+
+This command leverages MCP servers for enhanced research:
+
+### Context7 - Library Documentation (Primary)
+```
+ALWAYS use Context7 for library/framework research:
+1. Use resolve-library-id to find the library ID
+2. Use get-library-docs with topic parameter for focused docs
+3. Use mode='code' for API references, mode='info' for concepts
+```
+
+### Sequential Thinking - Structured Analysis
+```
+For complex research requiring step-by-step reasoning:
+- Use sequentialthinking tool to break down analysis
+- Track confidence scores for each finding
+- Revise conclusions as new information emerges
+```
+
+### Memory - Persistent Research
+```
+Store research findings for future reference:
+- Create entities for researched technologies
+- Add observations with pros/cons/recommendations
+- Link related technologies with relations
+```
+
 ## Output
 
 ```markdown

.claude/commands/review.md

@@ -291,6 +291,45 @@ Found **1 critical issue** (security), **2 recommendations**, and **2 suggestion
 | `quality` | Readability, maintainability |
 | `testing` | Coverage, test patterns |
 
+## MCP Integration
+
+This command leverages MCP servers for enhanced code review:
+
+### Playwright - Visual/UI Review
+```
+For reviewing UI changes:
+- Render and screenshot components
+- Compare visual changes across browsers
+- Verify responsive behavior
+- Check accessibility in real browser
+```
+
+### Memory - Review Context
+```
+Store and recall review context:
+- Remember past review decisions
+- Recall user's coding standards
+- Store patterns approved/rejected previously
+- Track recurring issues across reviews
+```
+
+### Sequential Thinking - Systematic Analysis
+```
+For thorough code analysis:
+- Step through complex logic systematically
+- Track multiple concerns in parallel
+- Build comprehensive issue list
+- Revise severity as context emerges
+```
+
+### Filesystem - Code Access
+```
+For reviewing file changes:
+- Use read_file to examine code
+- Use search_files to find related patterns
+- Check for similar issues across codebase
+```
+
 <!-- CUSTOMIZATION POINT -->
 ## Variations
 

.claude/commands/test.md

@@ -288,6 +288,44 @@ pytest tests/services/auth.test.ts -v
 | `jest` | JavaScript |
 | `playwright` | E2E (any) |
 
+## MCP Integration
+
+This command leverages MCP servers for enhanced testing:
+
+### Playwright - E2E Testing (Primary for UI)
+```
+For E2E and browser tests:
+- Use Playwright for cross-browser testing
+- Automate user flow verification
+- Capture screenshots for visual testing
+- Test on different device emulations
+```
+
+### Filesystem - Test File Management
+```
+For test file operations:
+- Use directory_tree to find test directories
+- Use search_files to find existing tests
+- Use read_file to check test patterns
+- Use write_file to create new test files
+```
+
+### Context7 - Testing Best Practices
+```
+For framework-specific testing:
+- Fetch current testing library docs
+- Get latest assertions and matchers
+- Find recommended testing patterns
+```
+
+### Memory - Test Patterns
+```
+Recall testing context:
+- Remember project testing conventions
+- Recall mock patterns used previously
+- Store common test fixtures
+```
+
 <!-- CUSTOMIZATION POINT -->
 ## Variations