External/SuperClaude
1
0
Fork 0
mirror of https://github.com/SuperClaude-Org/SuperClaude_Framework.git synced 2025-12-29 16:16:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: Optimize all 18 command files using @include reference system

Browse Source 
Major streamlining achievement:
- Eliminate 2,733 lines of duplicate content across commands
- Reduce individual command files by ~70% (130-150 → 35-60 lines)
- Leverage existing shared/*.yml reference patterns
- Maintain full Claude Code compliance

Benefits:
• Single source of truth for universal content
• Guaranteed consistency across all commands
• Dramatically reduced maintenance overhead
• Massive token efficiency improvements

Implementation:
- Universal Legend: @include shared/universal-constants.yml#Universal Legend
- Universal Flags: @include shared/flag-inheritance.yml#Universal_Always
- Command patterns: References to appropriate shared/*.yml files
- Template system: Enhanced command-patterns.yml

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
NomenAK
2025-06-24 22:46:52 +02:00
parent d8727a6a07
commit 219ff3905a
20 changed files with 1127 additions and 3860 deletions
Download Patch File Download Diff File Expand all files Collapse all files

387
.claude/commands/task.md
View File

@@ -1,38 +1,7 @@
# /task - Manage complex features and requirements
## Legend
| Symbol | Meaning | | Abbrev | Meaning |
|--------|---------|---|--------|---------|
| → | leads to | | cfg | configuration |
| & | and/with | | impl | implementation |
| w/ | with | | perf | performance |
| @ | at/located | | ops | operations |
| > | greater than | | val | validation |
| ∀ | for all/every | | req | requirements |
| ∃ | exists/there is | | deps | dependencies |
| ∴ | therefore | | env | environment |
| ∵ | because | | db | database |
| ≡ | equivalent | | api | interface |
| ≈ | approximately | | docs | documentation |
| 📁 | directory/path | | std | standard |
| 🔢 | number/count | | def | default |
| 📝 | text/string | | ctx | context |
| ⚙ | setting/config | | err | error |
| 🎛 | control/flags | | exec | execution |
| 🔧 | configuration | | qual | quality |
| 📋 | group/category | | rec | recovery |
| 🚨 | critical/urgent | | sev | severity |
| ⚠ | warning/caution | | resp | response |
| 🔄 | retry/recovery | | esc | escalation |
| ✅ | success/fixed | | tok | token |
| ❌ | failure/error | | opt | optimization |
| ℹ | information | | UX | user experience |
| ⚡ | fast/quick | | UI | user interface |
| 🐌 | slow/delayed | | C | critical |
| ✨ | complete/done | | H | high |
| 📖 | read operation | | M | medium |
| ✏ | edit operation | | L | low |
| 🗑 | delete operation | | |
@include shared/universal-constants.yml#Universal_Legend
## Purpose
Manage complex features and requirements across sessions with automatic breakdown, context preservation, and recovery capabilities.
@@ -40,271 +9,135 @@ Manage complex features and requirements across sessions with automatic breakdow
## Syntax
`/task [operation] [parameters]`
## Universal Flags
--plan: "Show execution plan before running"
--uc: "UltraCompressed mode (~70% token reduction)"
--ultracompressed: "Alias for --uc"
--think: "Multi-file analysis w/ context (4K tokens)"
--think-hard: "Deep architectural analysis (10K tokens)"
--ultrathink: "Critical system redesign (32K tokens)"
--c7: "Enable Context7→library documentation lookup"
--seq: "Enable Sequential→complex analysis & thinking"
--magic: "Enable Magic→UI component generation"
--pup: "Enable Puppeteer→browser automation & testing"
--all-mcp: "Enable all MCP servers"
--no-mcp: "Disable all MCP servers (native tools only)"
--no-c7: "Disable Context7 specifically"
--no-seq: "Disable Sequential thinking specifically"
--no-magic: "Disable Magic UI builder specifically"
--no-pup: "Disable Puppeteer specifically"
@include shared/flag-inheritance.yml#Universal_Always
## Command-Specific Operations
## Operations
**Task Operations:**
- `create <title>`: Create new task with automatic breakdown
- `list`: Show tasks filtered by status or priority
- `start <id>`: Begin working on specific task
- `pause <id>`: Pause current work and save context
- `resume <id>`: Resume previously paused task
- `complete <id>`: Mark task as completed with verification
- `cancel <id>`: Cancel task and clean up resources
- `show <id>`: Display detailed task information
- `update <id>`: Modify task status, priority, or details
/task:create [description]:
- Create new task with automatic breakdown
- Generate subtasks & milestones
- Set up tracking structure
- Initialize context preservation
**Task Types:**
- `--type feature`: New feature development
- `--type bugfix`: Bug resolution and fixes
- `--type refactor`: Code refactoring and improvement
- `--type docs`: Documentation creation or updates
- `--type test`: Testing implementation or enhancement
/task:update [task-id] [updates]:
- Update task progress
- Modify requirements
- Adjust timeline
- Add discoveries
**Priority Levels:**
- `--priority high`: Critical or urgent tasks
- `--priority medium`: Standard priority tasks (default)
- `--priority low`: Nice-to-have or future enhancements
/task:status [task-id]:
- Show current progress
- List completed subtasks
- Display blockers
- Estimate remaining work
**Status Filters:**
- `--status pending`: Tasks waiting to be started
- `--status in-progress`: Currently active tasks
- `--status completed`: Finished tasks
- `--status cancelled`: Cancelled or abandoned tasks
/task:resume [task-id]:
- Load task context
- Continue from last point
- Restore working state
- Update progress
## Examples
- `/task create "User authentication system" --type feature --priority high`
- `/task list --status pending --priority high`
- `/task start 20250623-143052`
- `/task pause 20250623-143052`
- `/task resume 20250623-143052`
- `/task complete 20250623-143052`
- `/task show 20250623-143052`
- `/task update 20250623-143052 --priority low`
/task:complete [task-id]:
- Mark task as done
- Generate summary
- Archive artifacts
- Create documentation
## Task Workflow
## Task Structure
**Task Creation:**
1. **Requirement Analysis**: Analyze complexity and scope
2. **ID Generation**: Create unique task ID (YYYYMMDD-HHMMSS)
3. **Breakdown**: Decompose into phases and actionable steps
4. **File Creation**: Generate task file from appropriate template
5. **Git Integration**: Create dedicated branch for task
6. **Organization**: Move to pending folder for tracking
@include shared/task-patterns.yml#Task_Structure
**Task Execution:**
1. **Activation**: Move task to in-progress folder
2. **Checkpoint**: Create git checkpoint for safety
3. **Sequential Execution**: Work through steps systematically
4. **Progress Tracking**: Update progress and context continuously
5. **Session Management**: Handle interruptions and breaks gracefully
Task Components:
- Title & description
- Acceptance criteria
- Technical requirements
- Subtask breakdown
- Progress tracking
- Context preservation
**Task Completion:**
1. **Verification**: Ensure all steps completed successfully
2. **Testing**: Run comprehensive tests and validation
3. **Checkpoint**: Create completion checkpoint
4. **Organization**: Move to completed folder
5. **Integration**: Merge git branch and clean up
## Automatic Features
## Auto-Detection
Smart Breakdown:
- Analyze complexity
- Create subtasks
- Identify dependencies
- Estimate effort
- Set milestones
**Complexity Triggers:**
- "build feature X" or "implement functionality Y"
- "add component Z" or "create system W"
- Requirements affecting more than 3 files
- Multi-step work requiring coordination
- Complex integration or architectural changes
Context Preservation:
- Save working state
- Track decisions
- Store code changes
- Maintain history
- Enable recovery
**System Response:**
- Analyze request complexity automatically
- Suggest task creation for complex work
- Provide options: [Create task breakdown] [Proceed directly]
- Explain benefits of task management approach
- Respect user preference for simple tasks
Progress Tracking:
- Update automatically
- Track blockers
- Monitor velocity
- Adjust estimates
- Report status
## Session Recovery
## Recovery System
**Startup Process:**
1. **Scan**: Check `.claudedocs/tasks/in-progress/` directory
2. **Identify**: Find active tasks and their current state
3. **Restore**: Load context from task files and git history
4. **Suggest**: Recommend next steps for resumption
@include shared/session-recovery.yml#Recovery_Patterns
**Context Preservation:**
- Key architectural decisions and rationale
- Current implementation state and progress
- Known blockers and proposed solutions
- File modification history and dependencies
- Integration points and testing requirements
## Task File Structure
**Directory Organization:**
```
.claudedocs/tasks/
├── pending/ # Tasks waiting to be started
├── in-progress/ # Currently active tasks
├── completed/ # Finished tasks
├── cancelled/ # Cancelled or abandoned tasks
└── templates/ # Task templates by type
```
**File Naming Convention:**
```
{type}-{id}-{slug}.md
Examples:
feature-20250623-143052-user-auth.md
bugfix-20250623-144022-login-error.md
refactor-20250623-142033-api-cleanup.md
```
**Task File Content:**
- Task metadata (ID, type, priority, status)
- Detailed description and requirements
- Phase breakdown with progress tracking
- Context and architectural decisions
- Blockers and resolution strategies
- Testing and validation requirements
## Integration Capabilities
**Git Integration:**
- Automatic branch creation and management
- Checkpoint creation for safety and rollback
- Merge strategy and conflict resolution
- Commit message generation and conventions
**TodoWrite Synchronization:**
- Sync with existing todo system
- Convert todos to tasks when appropriate
- Maintain consistency across systems
- Provide unified task management experience
**Persona Activation:**
- Task-specific persona selection
- Specialized expertise for different task types
- Context-aware skill application
- Collaborative persona workflows
**MCP Integration:**
- Context preservation across MCP tools
- State management for complex operations
- Tool coordination for task execution
- Resource optimization and sharing
**Command Chaining:**
- Chain with other SuperClaude commands
- Workflow automation and optimization
- Cross-command context sharing
- Integrated development experience
## Advanced Features
**Task Dependencies:**
- Define prerequisite relationships
- Automatic dependency resolution
- Blocked task identification
- Parallel execution planning
**Progress Tracking:**
- Phase-based progress measurement
- Milestone tracking and reporting
- Time estimation and actual tracking
- Velocity and performance metrics
**Collaboration Support:**
- Multi-contributor task support
- Handoff procedures and documentation
- Knowledge transfer mechanisms
- Team coordination features
## Deliverables
- **Task Files**: Comprehensive task documentation with progress tracking
- **Git Branches**: Dedicated branches with checkpoint history
- **Progress Reports**: Regular status updates and metrics
- **Context Documentation**: Preserved decision-making rationale
- **Integration Plans**: Merge and deployment strategies
## Research Requirements
External_Library_Research:
- Identify library/framework mentioned
- Context7 lookup for official documentation
- Verify API patterns and examples
- Check version compatibility
- Document findings in implementation
Pattern_Research:
- Search existing codebase for similar patterns
- Magic component search if UI-related
- WebSearch for official documentation
- Validate approach with Sequential thinking
- Document pattern choice rationale
API_Integration_Research:
- Official documentation lookup
- Authentication requirements
- Rate limiting and error handling
- SDK availability and examples
- Integration testing approach
## Report Notifications
📄 Analysis report saved to: {path}
📊 Metrics updated: {path}
📋 Summary saved to: {path}
💾 Checkpoint created: {path}
📚 Documentation created: {path}
📁 Created directory: {path}
✅ {operation} completed successfully
❌ {operation} failed: {reason}
⚠ {operation} completed w/ warnings
Session Recovery:
- Auto-detect incomplete tasks
- Load previous context
- Resume from checkpoint
- Maintain continuity
- Preserve momentum
## Best Practices
**Task Creation:**
- Define clear, specific objectives
- Break down complex work into manageable phases
- Set realistic timelines and expectations
- Include comprehensive context and requirements
- Plan for testing and validation
Task Creation:
- Clear requirements
- Measurable outcomes
- Realistic scope
- Defined boundaries
- Success criteria
**Execution Management:**
- Update progress regularly and consistently
- Document decisions and changes promptly
- Handle blockers and dependencies proactively
- Maintain clean git history and commits
- Communicate status changes effectively
Task Management:
- Regular updates
- Track blockers early
- Document decisions
- Test incrementally
- Communicate progress
**Quality Assurance:**
- Verify completion criteria before marking done
- Run comprehensive tests and validation
- Review code quality and standards compliance
- Update documentation and knowledge base
- Plan for maintenance and future enhancements
## Examples
## Troubleshooting
- **Complex Tasks**: Use automatic breakdown with phase management
- **Session Interruptions**: Leverage auto-save and context preservation
- **Integration Issues**: Apply git checkpoints and rollback capabilities
- **Progress Tracking**: Use detailed phase and milestone tracking
```bash
# Create complex feature task
/task:create "Implement OAuth 2.0 authentication system"
## Success Messages
✅ {operation} completed successfully
📝 Created: {file_path}
✏ Updated: {file_path}
✨ Task completed: {task_title}
# Check task status
/task:status oauth-task-id
# Resume work after break
/task:resume oauth-task-id
# Update with discoveries
/task:update oauth-task-id "Found library conflict, switching approach"
# Complete with summary
/task:complete oauth-task-id
```
## Integration
Works with:
- TodoWrite for subtasks
- Git for version control
- Test for validation
- Document for artifacts
- All development commands
## Deliverables
- Task breakdown document
- Progress tracking reports
- Technical decisions log
- Implementation artifacts
- Completion summary
- Lessons learned