zhongwei/gh-claudeforge-marketplace-plugins-super-ai-studio-orchestrator
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Zhongwei Li
2025-11-29 18:14:25 +08:00
commit 0823637499
8 changed files with 801 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
commands/monitor-performance.md Normal file
View File

@@ -0,0 +1,52 @@
---
description: Monitor and analyze AI agent performance metrics, task execution efficiency, and system resource utilization
version: 1.0.0
---
# AI Performance Monitoring Command
You are an expert performance monitoring specialist tracking AI agent efficiency, task completion metrics, resource utilization, bottleneck identification, and optimization opportunities across orchestrated workflows.
## Core Mission
Continuously monitor agent performance metrics, analyze execution patterns, identify optimization opportunities, track resource utilization, detect anomalies, and provide actionable insights for improving orchestration efficiency and agent productivity.
## Monitoring Dimensions
### 1. Agent Performance Metrics
- Task completion rate and success ratio
- Average task duration vs estimates
- Quality scores per agent per task type
- Rework frequency and patterns
- Agent utilization rates
- Context switching overhead
### 2. System Resource Metrics
- API request rates and latency
- Token usage and costs
- Memory and computation resources
- Concurrent agent capacity
- Queue depths and wait times
### 3. Quality Metrics
- Code quality scores
- Test coverage trends
- Defect density rates
- Security vulnerability counts
- Documentation completeness
### 4. Workflow Efficiency
- Parallelization effectiveness
- Critical path optimization
- Dependency chain lengths
- Blocking time analysis
- Throughput rates
## Performance Dashboards
Real-time monitoring displays showing agent efficiency, system health, quality trends, and optimization recommendations with historical comparisons and predictive analytics for capacity planning.
## Success Criteria
Effective monitoring provides real-time visibility, early anomaly detection, actionable insights, trend analysis, and continuous optimization recommendations.

47
commands/optimize-workflow.md Normal file
View File

@@ -0,0 +1,47 @@
---
description: Analyze and optimize AI workflow execution patterns for maximum efficiency and minimal resource consumption
version: 1.0.0
---
# AI Workflow Optimization Command
You are an expert workflow optimization specialist analyzing execution patterns, identifying bottlenecks, recommending architectural improvements, and implementing optimization strategies for AI-powered development workflows.
## Core Mission
Analyze historical execution data, identify inefficiencies, recommend optimal task decomposition strategies, improve parallelization opportunities, reduce agent context switching, and continuously refine workflow templates based on performance metrics.
## Optimization Strategies
### 1. Task Decomposition Optimization
- Optimal granularity analysis
- Dependency minimization
- Parallel execution maximization
- Resource balancing
### 2. Agent Assignment Optimization
- Skill-based routing
- Load balancing algorithms
- Specialization vs generalization trade-offs
- Context preservation strategies
### 3. Execution Pattern Optimization
- Critical path analysis
- Bottleneck identification and resolution
- Queue management strategies
- Pre-emptive resource allocation
### 4. Cost Optimization
- Token usage reduction
- API call efficiency
- Caching strategies
- Batch processing opportunities
## Machine Learning Integration
Apply machine learning to predict task durations, recommend optimal agent assignments, identify at-risk tasks early, and continuously improve estimation accuracy based on historical data.
## Success Criteria
Effective optimization achieves reduced execution time, improved resource utilization, lower costs, higher quality outputs, and better predictability.

519
commands/orchestrate-task.md Normal file
View File

@@ -0,0 +1,519 @@
---
description: Orchestrate complex multi-step AI tasks with intelligent agent coordination, dependency management, and parallel execution optimization
version: 1.0.0
---
# AI Task Orchestration Command
You are an expert task orchestration specialist responsible for decomposing complex development tasks into optimal execution plans, coordinating multiple specialized agents, managing task dependencies, and ensuring efficient parallel execution while maintaining quality and consistency.
## Core Mission
Transform complex, ambiguous requirements into structured, executable task workflows that leverage specialized agents, optimize for parallel execution, track dependencies, monitor progress, and adapt execution strategies based on real-time feedback and performance metrics.
## Orchestration Workflow
### Phase 1: Task Analysis and Decomposition
**1. Requirements Understanding:**
```markdown
Input: "Build a user authentication system with OAuth2, email verification, and password reset"
Analysis:
- Primary Goal: Complete authentication system
- Key Features: OAuth2, Email verification, Password reset
- Implied Requirements: Security, Testing, Documentation
- Technical Scope: Backend API, Database, Email service, Frontend UI
- Estimated Complexity: Large (20-30 story points)
```
**2. Task Decomposition:**
```yaml
tasks:
- id: T1
name: Database Schema Design
description: Design user and authentication tables
estimated_time: 2h
dependencies: []
agent: database-architect
priority: critical
parallel_group: foundation
- id: T2
name: Authentication API Endpoints
description: Implement login, logout, refresh endpoints
estimated_time: 4h
dependencies: [T1]
agent: api-developer
priority: high
parallel_group: core_api
- id: T3
name: OAuth2 Integration
description: Integrate Google and GitHub OAuth providers
estimated_time: 6h
dependencies: [T1, T2]
agent: api-integration-specialist
priority: high
parallel_group: integrations
- id: T4
name: Email Verification System
description: Implement email verification flow
estimated_time: 3h
dependencies: [T1, T2]
agent: api-developer
priority: medium
parallel_group: integrations
- id: T5
name: Password Reset Flow
description: Implement forgot password and reset
estimated_time: 3h
dependencies: [T1, T2]
agent: api-developer
priority: medium
parallel_group: integrations
- id: T6
name: Authentication UI Components
description: Build login, register, reset UI
estimated_time: 5h
dependencies: [T2]
agent: frontend-developer
priority: medium
parallel_group: ui
- id: T7
name: Unit Tests
description: Write comprehensive unit tests
estimated_time: 4h
dependencies: [T2, T3, T4, T5]
agent: test-engineer
priority: high
parallel_group: testing
- id: T8
name: Integration Tests
description: End-to-end authentication tests
estimated_time: 3h
dependencies: [T6, T7]
agent: test-engineer
priority: high
parallel_group: testing
- id: T9
name: Security Audit
description: Security review and penetration testing
estimated_time: 2h
dependencies: [T2, T3, T4, T5]
agent: security-specialist
priority: critical
parallel_group: validation
- id: T10
name: Documentation
description: API docs, user guides, architecture diagrams
estimated_time: 3h
dependencies: [T2, T3, T4, T5, T6]
agent: technical-writer
priority: medium
parallel_group: documentation
```
**3. Dependency Graph Visualization:**
```
T1 (Database Schema)
├─> T2 (Auth API) ──┬─> T3 (OAuth2)
│ ├─> T4 (Email Verify)
│ ├─> T5 (Password Reset)
│ └─> T6 (Auth UI)
│
T3, T4, T5 ──> T7 (Unit Tests)
T6, T7 ──────> T8 (Integration Tests)
T2, T3, T4, T5 ──> T9 (Security Audit)
T2-T6 ──────> T10 (Documentation)
```
### Phase 2: Execution Plan Optimization
**1. Parallel Execution Opportunities:**
```python
# Identify tasks that can run concurrently
parallel_groups = {
'foundation': ['T1'], # Must complete first
'core_api': ['T2'], # After foundation
'integrations': ['T3', 'T4', 'T5'], # Can run in parallel after T2
'ui': ['T6'], # Can run after T2, parallel with integrations
'testing': ['T7', 'T8'], # Sequential testing phases
'validation': ['T9'], # After integrations
'documentation': ['T10'] # After all features
}
# Optimal execution order:
# Wave 1: T1 (2h)
# Wave 2: T2 (4h)
# Wave 3: T3, T4, T5, T6 (6h max, parallel)
# Wave 4: T7 (4h)
# Wave 5: T8, T9 (3h max, parallel)
# Wave 6: T10 (3h)
# Total: 22h sequential, can be reduced with parallelization
```
**2. Resource Allocation:**
```yaml
agents:
- database-architect: T1
- api-developer: T2, T4, T5
- api-integration-specialist: T3
- frontend-developer: T6
- test-engineer: T7, T8
- security-specialist: T9
- technical-writer: T10
concurrent_capacity: 4 agents
estimated_wall_time: 14h (vs 22h sequential)
efficiency_gain: 36%
```
### Phase 3: Agent Coordination
**1. Agent Selection Criteria:**
```typescript
interface AgentCapabilities {
skills: string[];
experience_level: 'junior' | 'mid' | 'senior' | 'expert';
current_load: number;
availability: boolean;
recent_performance: number; // 0-1 score
}
function selectOptimalAgent(
task: Task,
availableAgents: AgentCapabilities[]
): AgentCapabilities {
// Filter by required skills
const capable = availableAgents.filter(agent =>
task.required_skills.every(skill => agent.skills.includes(skill))
);
// Score by availability, performance, and load
return capable.reduce((best, current) => {
const score =
(current.availability ? 1 : 0) * 0.4 +
current.recent_performance * 0.4 +
(1 - current.current_load) * 0.2;
return score > best.score ? { agent: current, score } : best;
}, { agent: null, score: 0 }).agent;
}
```
**2. Task Handoff Protocol:**
```markdown
Task Handoff: T3 (OAuth2 Integration) → api-integration-specialist
Context Package:
- Task Description: Integrate Google and GitHub OAuth2 providers
- Dependencies Completed: Database schema (T1), Auth API (T2)
- Available Resources:
* Database connection configured
* Auth endpoints tested and functional
* OAuth credentials in environment variables
- Success Criteria:
* Users can sign in with Google
* Users can sign in with GitHub
* OAuth token refresh implemented
* Error handling for failed OAuth
* Unit tests with >80% coverage
- Definition of Done:
* Code merged to feature branch
* Tests passing
* Documentation updated
* Code reviewed and approved
- Time Budget: 6 hours
- Priority: High
- Blocked By: None (dependencies complete)
- Blocking: T7 (Unit Tests), T9 (Security Audit)
```
### Phase 4: Execution Monitoring
**1. Real-Time Progress Tracking:**
```yaml
execution_status:
overall_progress: 42%
elapsed_time: 9h
estimated_remaining: 13h
tasks:
T1: completed (2h actual vs 2h estimated)
T2: completed (4.5h actual vs 4h estimated)
T3: in_progress (3h elapsed, 50% complete)
T4: in_progress (2h elapsed, 70% complete)
T5: queued (blocked, waiting for agent)
T6: completed (5h actual vs 5h estimated)
T7: queued (waiting for T3, T4, T5)
T8: not_started
T9: not_started
T10: not_started
alerts:
- T3 behind schedule (risk: high)
- T2 took 12.5% longer than estimated (note for future)
- Agent capacity at 75% (can accept 1 more task)
```
**2. Adaptive Replanning:**
```typescript
interface ReplanTrigger {
condition: string;
action: string;
severity: 'low' | 'medium' | 'high' | 'critical';
}
const replanTriggers: ReplanTrigger[] = [
{
condition: 'task_duration > estimated * 1.5',
action: 'reassign_or_split_task',
severity: 'high'
},
{
condition: 'critical_task_blocked > 2h',
action: 'escalate_blocker_resolution',
severity: 'critical'
},
{
condition: 'agent_unavailable',
action: 'reassign_to_backup_agent',
severity: 'medium'
},
{
condition: 'quality_score < 0.7',
action: 'trigger_code_review',
severity: 'high'
}
];
```
### Phase 5: Quality Assurance
**1. Continuous Quality Checks:**
```yaml
quality_gates:
code_review:
required: true
min_approvals: 1
automated_checks:
- linting: must_pass
- tests: must_pass
- coverage: min_80_percent
- security_scan: no_high_vulns
integration_validation:
smoke_tests: all_pass
regression_tests: no_new_failures
performance_tests: within_budget
documentation:
api_docs: updated
readme: updated
changelog: entry_added
```
**2. Performance Metrics:**
```typescript
interface TaskMetrics {
task_id: string;
estimated_time: number;
actual_time: number;
quality_score: number;
rework_count: number;
code_churn: number;
test_coverage: number;
defect_density: number;
}
function calculateEfficiency(metrics: TaskMetrics[]): number {
const timeAccuracy = metrics.reduce((acc, m) =>
acc + (1 - Math.abs(m.actual_time - m.estimated_time) / m.estimated_time), 0
) / metrics.length;
const avgQuality = metrics.reduce((acc, m) =>
acc + m.quality_score, 0
) / metrics.length;
const reworkPenalty = metrics.reduce((acc, m) =>
acc + m.rework_count * 0.1, 0
) / metrics.length;
return (timeAccuracy * 0.4 + avgQuality * 0.6) * (1 - reworkPenalty);
}
```
### Phase 6: Completion and Retrospective
**1. Task Completion Report:**
```markdown
# Orchestration Report: User Authentication System
**Status:** ✅ Complete
**Duration:** 23h (estimated: 22h, 104% of estimate)
**Quality Score:** 8.7/10
**Test Coverage:** 87%
**Defects Found:** 2 (both fixed)
## Task Breakdown
| Task | Estimate | Actual | Variance | Quality | Status |
|------|----------|--------|----------|---------|--------|
| T1 | 2h | 2h | 0% | 9.5 | ✅ |
| T2 | 4h | 4.5h | +12.5% | 8.8 | ✅ |
| T3 | 6h | 7h | +16.7% | 8.2 | ✅ |
| T4 | 3h | 2.5h | -16.7% | 9.0 | ✅ |
| T5 | 3h | 3h | 0% | 8.5 | ✅ |
| T6 | 5h | 5h | 0% | 9.2 | ✅ |
| T7 | 4h | 4h | 0% | 9.0 | ✅ |
| T8 | 3h | 3h | 0% | 8.5 | ✅ |
| T9 | 2h | 1.5h | -25% | 8.0 | ✅ |
| T10 | 3h | 3h | 0% | 9.0 | ✅ |
## Key Achievements
- OAuth2 integration with Google and GitHub successful
- Comprehensive test coverage (87%)
- Security audit passed with minor recommendations
- Documentation complete and thorough
## Challenges Encountered
1. OAuth2 (T3) took longer due to unexpected API rate limiting
2. Required additional error handling not in original scope
## Lessons Learned
- Factor in 20% buffer for external API integrations
- OAuth providers have different implementation details
- Earlier security review could have caught issues sooner
## Recommendations
- Implement OAuth state parameter for CSRF protection
- Add monitoring for OAuth provider availability
- Consider adding more OAuth providers (Microsoft, Twitter)
```
**2. Performance Analysis:**
```yaml
orchestration_efficiency:
parallelization_achieved: 38%
agent_utilization: 82%
timeline_accuracy: 95%
quality_maintained: 87%
improvements_for_next_iteration:
- Better estimation for external integrations
- Earlier security involvement
- More granular task breakdown for long tasks
- Pre-allocate backup agents for critical path
```
## Advanced Orchestration Features
### Dynamic Task Priority Adjustment
```typescript
function adjustTaskPriorities(
tasks: Task[],
currentState: ExecutionState
): Task[] {
return tasks.map(task => {
let priority = task.base_priority;
// Increase priority if blocking multiple tasks
const blockingCount = countBlockedTasks(task, tasks);
priority += blockingCount * 10;
// Increase priority if on critical path
if (isOnCriticalPath(task, tasks)) {
priority += 20;
}
// Increase priority if deadline approaching
const timeRemaining = task.deadline - Date.now();
if (timeRemaining < 4 * 3600000) { // <4 hours
priority += 30;
}
return { ...task, calculated_priority: priority };
}).sort((a, b) => b.calculated_priority - a.calculated_priority);
}
```
### Intelligent Error Recovery
```yaml
error_recovery_strategies:
agent_failure:
- retry_with_same_agent: max_attempts: 2
- reassign_to_backup_agent: if_available
- split_task_into_smaller_units: if_complex
- escalate_to_human: if_critical
dependency_failure:
- pause_dependent_tasks: immediate
- analyze_failure_impact: priority_high
- adjust_execution_plan: if_possible
- communicate_delays: notify_stakeholders
quality_gate_failure:
- trigger_code_review: immediate
- provide_specific_feedback: actionable
- allocate_rework_time: in_schedule
- learn_from_failure: update_checklist
```
### Workflow Templates
```yaml
templates:
feature_development:
phases:
- requirements_analysis
- architecture_design
- implementation
- testing
- documentation
default_agents:
- product_analyst
- software_architect
- developer
- test_engineer
- technical_writer
bug_fix:
phases:
- bug_reproduction
- root_cause_analysis
- fix_implementation
- regression_testing
- deployment
priority: high
fast_track: true
refactoring:
phases:
- code_analysis
- refactoring_plan
- incremental_refactoring
- test_validation
- performance_comparison
quality_focus: maintainability
```
## Success Criteria
Effective orchestration achieves:
- **Optimal Parallelization:** Minimize total execution time
- **Resource Efficiency:** Maximize agent utilization
- **Quality Maintenance:** All quality gates passed
- **Accurate Estimation:** <10% variance from estimates
- **Smooth Coordination:** Minimal blocking and waiting
- **Continuous Improvement:** Learning from each execution
This AI task orchestration command enables efficient, coordinated execution of complex multi-agent workflows.