7.4 KiB
7.4 KiB
description
| description |
|---|
| Assess plugin implementation complexity and estimate development effort |
Estimate Plugin Complexity
Parameters
Required:
operations: Number of operations/commands (format: integer)
Optional:
has_scripts: Whether utility scripts are needed (format: true|false, default: false)has_agents: Whether agents are included (format: true|false, default: false)has_hooks: Whether hooks are included (format: true|false, default: false)has_mcp: Whether MCP servers are needed (format: true|false, default: false)external_apis: Number of external API integrations (format: integer, default: 0)
Workflow
Step 1: Calculate Base Complexity
Operation Complexity Score:
- 1-2 operations: Base score = 1 (Simple)
- 3-5 operations: Base score = 2 (Moderate)
- 6-8 operations: Base score = 3 (Complex)
- 9+ operations: Base score = 4 (Very Complex)
Step 2: Apply Component Multipliers
Complexity Multipliers:
Scripts (+0.5 per script type):
- Shell scripts (.sh): +0.5
- Python scripts (.py): +0.5
- JavaScript scripts (.js): +0.5
- Average scripts needed: operations / 3 (rounded up)
Agents (+1.0 per agent):
- Agent design and prompting: +0.5
- Agent capabilities definition: +0.3
- Agent tool configuration: +0.2
- Testing and refinement: +0.3
- Total per agent: +1.3
Hooks (+0.5 per hook event):
- Hook configuration: +0.2
- Event matcher design: +0.2
- Hook script implementation: +0.3
- Testing hook triggers: +0.3
- Total per hook: +1.0
MCP Servers (+2.0 per server):
- Server design: +0.5
- Tool implementation: +0.8
- Configuration setup: +0.3
- Testing and debugging: +0.4
- Total per MCP server: +2.0
External API Integrations (+0.8 per API):
- Authentication setup: +0.3
- API wrapper implementation: +0.3
- Error handling: +0.2
- Total per API: +0.8
Step 3: Calculate Total Complexity
Formula:
Total Complexity = Base Score
+ (script_count * 0.5)
+ (agent_count * 1.3)
+ (hook_count * 1.0)
+ (mcp_count * 2.0)
+ (api_count * 0.8)
Complexity Bands:
- 0-2: Very Low
- 2.1-4: Low
- 4.1-6: Moderate
- 6.1-8: High
- 8+: Very High
Step 4: Estimate Time Investment
Time Per Complexity Band:
Very Low (0-2):
- Planning: 5-10 minutes
- Implementation: 10-15 minutes
- Testing: 5-10 minutes
- Documentation: 10-15 minutes
- Total: 30-50 minutes
Low (2.1-4):
- Planning: 10-15 minutes
- Implementation: 20-30 minutes
- Testing: 10-15 minutes
- Documentation: 15-20 minutes
- Total: 55-80 minutes
Moderate (4.1-6):
- Planning: 15-20 minutes
- Implementation: 40-60 minutes
- Testing: 20-30 minutes
- Documentation: 20-30 minutes
- Total: 95-140 minutes (1.5-2.5 hours)
High (6.1-8):
- Planning: 20-30 minutes
- Implementation: 80-120 minutes
- Testing: 30-45 minutes
- Documentation: 30-40 minutes
- Total: 160-235 minutes (2.5-4 hours)
Very High (8+):
- Planning: 30-45 minutes
- Implementation: 120-180+ minutes
- Testing: 45-60 minutes
- Documentation: 40-60 minutes
- Total: 235-345+ minutes (4-6+ hours)
Step 5: Identify Complexity Drivers
Major Complexity Drivers:
- High operation count (6+)
- MCP server integration (highest impact)
- Complex state management
- Multiple external APIs
- Custom hooks with sophisticated matchers
- Agent with extensive capabilities
Risk Factors:
- First-time MCP server development: +50% time
- Complex authentication: +30% time
- Unfamiliar external APIs: +40% time
- Testing infrastructure setup: +20% time
Step 6: Generate Estimate Report
Provide comprehensive estimate with:
- Complexity score and band
- Time estimate with breakdown
- Complexity drivers
- Risk factors
- Recommendations for scope management
- Phased implementation plan
Output Format
## Plugin Complexity Estimate
### Input Parameters
- **Operations**: {count}
- **Scripts**: {yes/no} ({estimated count})
- **Agents**: {yes/no} ({count})
- **Hooks**: {yes/no} ({count})
- **MCP Servers**: {yes/no} ({count})
- **External APIs**: {count}
### Complexity Analysis
**Base Complexity**: {score} ({Simple|Moderate|Complex|Very Complex})
**Component Adjustments**:
- Scripts: +{score} ({count} scripts)
- Agents: +{score} ({count} agents)
- Hooks: +{score} ({count} hooks)
- MCP Servers: +{score} ({count} servers)
- External APIs: +{score} ({count} APIs)
**Total Complexity Score**: {total} / 10
**Complexity Band**: {Very Low|Low|Moderate|High|Very High}
### Time Estimate
**Breakdown**:
- Planning & Design: {time range}
- Implementation: {time range}
- Testing & Debugging: {time range}
- Documentation: {time range}
**Total Estimated Time**: {time range}
**Confidence Level**: {High|Medium|Low}
(Based on requirements clarity and risk factors)
### Complexity Drivers
**Major Drivers** (Highest Impact):
1. {driver 1}: {impact explanation}
2. {driver 2}: {impact explanation}
3. {driver 3}: {impact explanation}
**Minor Drivers**:
- {driver}: {impact}
### Risk Factors
**Technical Risks**:
- {risk 1}: {mitigation strategy}
- {risk 2}: {mitigation strategy}
**Time Risks**:
- {risk}: Potential +{percentage}% time increase
### Recommendations
**Scope Management**:
{Recommendations for managing complexity}
**Simplification Opportunities**:
- {opportunity 1}: Could reduce complexity by {amount}
- {opportunity 2}: Could reduce complexity by {amount}
**Phased Implementation**:
**Phase 1 (MVP)**: {time estimate}
- {core component 1}
- {core component 2}
- {core component 3}
**Phase 2 (Enhanced)**: {time estimate}
- {enhancement 1}
- {enhancement 2}
**Phase 3 (Full-Featured)**: {time estimate}
- {advanced feature 1}
- {advanced feature 2}
### Comparison to Similar Plugins
**Similar Complexity**:
- {example plugin 1}: {comparison}
- {example plugin 2}: {comparison}
**Reference Implementation Time**:
- Simple plugin (e.g., hello-world): 30-45 minutes
- Moderate plugin (e.g., code-formatter): 1-2 hours
- Complex plugin (e.g., deployment-automation): 3-5 hours
- Very complex plugin (e.g., test-framework): 5-8+ hours
### Success Factors
**To Stay On Track**:
1. {factor 1}
2. {factor 2}
3. {factor 3}
**Red Flags to Watch**:
- {warning sign 1}
- {warning sign 2}
Error Handling
- Invalid operation count → Request valid positive integer
- Unrealistic parameters → Clarify actual requirements
- Missing critical info → Ask about components planned
- Scope creep indicators → Warn about complexity explosion
Examples
Example 1: Simple Plugin
Input:
operations:2 has_scripts:false has_agents:false has_hooks:false has_mcp:false
Estimate:
- Complexity: 1.0 (Very Low)
- Time: 30-50 minutes
- Band: Very Low
- Confidence: High
Example 2: Moderate Plugin
Input:
operations:5 has_scripts:true has_agents:true has_hooks:false has_mcp:false
Estimate:
- Base: 2.0
- Scripts: +1.5 (3 scripts estimated)
- Agents: +1.3 (1 agent)
- Total: 4.8 (Moderate)
- Time: 90-120 minutes
- Confidence: Medium
Example 3: Complex Plugin
Input:
operations:7 has_scripts:true has_agents:true has_hooks:true has_mcp:true external_apis:2
Estimate:
- Base: 3.0
- Scripts: +2.0 (4 scripts)
- Agents: +1.3 (1 agent)
- Hooks: +1.0 (1 hook)
- MCP: +2.0 (1 server)
- APIs: +1.6 (2 APIs)
- Total: 10.9 (Very High)
- Time: 4-6+ hours
- Confidence: Medium-Low (high complexity)
Recommendation: Consider phased approach, starting with core 3-4 operations
Request: $ARGUMENTS