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