Initial commit
This commit is contained in:
Zhongwei Li
12
.claude-plugin/plugin.json
Normal file
12
.claude-plugin/plugin.json
Normal file
@@ -0,0 +1,12 @@
|
||||
{
|
||||
"name": "menon-core",
|
||||
"description": "Core functionality plugin for the menon ecosystem with feature management and configuration capabilities.",
|
||||
"version": "1.0.0",
|
||||
"author": {
|
||||
"name": "Eduardo Menoncello",
|
||||
"email": "eduardo@menoncello.com"
|
||||
},
|
||||
"agents": [
|
||||
"./agents"
|
||||
]
|
||||
}
|
||||
3
README.md
Normal file
3
README.md
Normal file
@@ -0,0 +1,3 @@
|
||||
# menon-core
|
||||
|
||||
Core functionality plugin for the menon ecosystem with feature management and configuration capabilities.
|
||||
8
agents/orchestrator/.prettierrc
Normal file
8
agents/orchestrator/.prettierrc
Normal file
@@ -0,0 +1,8 @@
|
||||
{
|
||||
"semi": true,
|
||||
"trailingComma": "es5",
|
||||
"singleQuote": true,
|
||||
"printWidth": 80,
|
||||
"tabWidth": 2,
|
||||
"useTabs": false
|
||||
}
|
||||
301
agents/orchestrator/README.md
Normal file
301
agents/orchestrator/README.md
Normal file
@@ -0,0 +1,301 @@
|
||||
# Orchestrator Agent
|
||||
|
||||
Advanced orchestration agent for managing subagents, commands, MCP servers, and skills with parallel execution capabilities.
|
||||
|
||||
## Overview
|
||||
|
||||
The Orchestrator Agent is a sophisticated management system designed to coordinate and optimize the execution of multiple AI agents, skills, and resources within the Claude Code ecosystem. It serves as the central hub for task planning, resource allocation, and parallel execution optimization.
|
||||
|
||||
## Key Features
|
||||
|
||||
### 🎯 **Agent Management**
|
||||
|
||||
- Discover and manage all available agents in the system
|
||||
- Track agent performance and capabilities
|
||||
- Optimal agent selection based on skills and tools
|
||||
- Performance monitoring and analytics
|
||||
|
||||
### 📋 **Task Planning & Execution**
|
||||
|
||||
- Create comprehensive task plans with dependencies
|
||||
- Parallel execution of compatible tasks
|
||||
- Intelligent task scheduling and resource allocation
|
||||
- Dependency resolution and execution ordering
|
||||
|
||||
### 🔧 **Skill & Command Coordination**
|
||||
|
||||
- Discover available skills across all agents
|
||||
- Intelligent skill-to-task matching
|
||||
- Command execution management
|
||||
- MCP server coordination
|
||||
|
||||
### ⚡ **Resource Optimization**
|
||||
|
||||
- Dynamic resource allocation and balancing
|
||||
- Performance monitoring and threshold management
|
||||
- Automatic scaling and optimization
|
||||
- Bottleneck detection and resolution
|
||||
|
||||
### 🔄 **Workflow Templates**
|
||||
|
||||
- Pre-built workflow templates for common scenarios
|
||||
- Custom workflow creation and management
|
||||
- Workflow execution monitoring
|
||||
- Performance analytics and insights
|
||||
|
||||
## Architecture
|
||||
|
||||
### Core Components
|
||||
|
||||
1. **OrchestratorAgent**: Main orchestration engine
|
||||
2. **OrchestrationManagementSkill**: Workflow and template management
|
||||
3. **ResourceOptimizerSkill**: Resource allocation and optimization
|
||||
|
||||
### Key Interfaces
|
||||
|
||||
- **AgentCapability**: Defines agent skills, tools, and performance
|
||||
- **TaskPlan**: Comprehensive task definition with dependencies
|
||||
- **ResourcePool**: Resource allocation and management
|
||||
- **WorkflowTemplate**: Reusable workflow definitions
|
||||
|
||||
## Usage Examples
|
||||
|
||||
### Basic Task Orchestration
|
||||
|
||||
```typescript
|
||||
import OrchestratorAgent from './index';
|
||||
|
||||
const orchestrator = new OrchestratorAgent();
|
||||
await orchestrator.initialize();
|
||||
|
||||
// Create a task plan
|
||||
const taskId = await orchestrator.createTaskPlan('Code review task', {
|
||||
requiredSkills: ['code-review', 'security-analysis'],
|
||||
requiredTools: ['Read', 'Write', 'Bash'],
|
||||
priority: 1,
|
||||
});
|
||||
|
||||
// Execute the task
|
||||
await orchestrator.executeTask(taskId);
|
||||
```
|
||||
|
||||
### Workflow Template Execution
|
||||
|
||||
```typescript
|
||||
import OrchestrationManagementSkill from './skills/orchestration-management';
|
||||
|
||||
const orchestrationSkill = new OrchestrationManagementSkill(orchestrator);
|
||||
|
||||
// Execute a predefined workflow
|
||||
const workflowId = await orchestrationSkill.executeWorkflow(
|
||||
'code-review-workflow',
|
||||
{
|
||||
parameters: { repo: 'my-repo', branch: 'feature-branch' },
|
||||
agentOverrides: {
|
||||
'security-analysis': 'superpowers:code-reviewer',
|
||||
},
|
||||
}
|
||||
);
|
||||
```
|
||||
|
||||
### Resource Optimization
|
||||
|
||||
```typescript
|
||||
import ResourceOptimizerSkill from './skills/resource-optimizer';
|
||||
|
||||
const optimizer = new ResourceOptimizerSkill(orchestrator);
|
||||
|
||||
// Optimize resource allocation
|
||||
const optimization = await optimizer.optimizeResources();
|
||||
console.log('Optimizations applied:', optimization.optimizations);
|
||||
console.log('Recommendations:', optimization.recommendations);
|
||||
|
||||
// Generate performance report
|
||||
const report = optimizer.generatePerformanceReport();
|
||||
console.log('Performance summary:', report.summary);
|
||||
```
|
||||
|
||||
## Available Agents
|
||||
|
||||
The orchestrator automatically discovers and manages these agent types:
|
||||
|
||||
### General Purpose Agents
|
||||
|
||||
- `general-purpose` - General tasks and web search
|
||||
- `Explore` - Fast codebase exploration
|
||||
- `Plan` - Project planning and architecture
|
||||
|
||||
### Code Review & Quality
|
||||
|
||||
- `superpowers:code-reviewer` - Security and performance analysis
|
||||
- `pr-review-toolkit:code-reviewer` - PR-specific reviews
|
||||
- `pr-review-toolkit:code-simplifier` - Code simplification
|
||||
- `feature-dev:code-reviewer` - Feature-specific reviews
|
||||
|
||||
### Development & Architecture
|
||||
|
||||
- `feature-dev:code-architect` - Solution architecture
|
||||
- `feature-dev:code-explorer` - Deep codebase analysis
|
||||
- `agent-creator` - Agent and skill development
|
||||
|
||||
### Specialized Tools
|
||||
|
||||
- `lint-typescript-fixer` - Advanced TypeScript fixing
|
||||
- `astrojs-specialist` - Astro.js development
|
||||
- `studio-cc:cc-expert` - Studio-CC expertise
|
||||
|
||||
## Workflow Templates
|
||||
|
||||
### Pre-built Templates
|
||||
|
||||
1. **Code Review Workflow**
|
||||
- Static analysis
|
||||
- Security review (parallel)
|
||||
- Performance review (parallel)
|
||||
- Documentation review
|
||||
|
||||
2. **Feature Development Workflow**
|
||||
- Requirements analysis
|
||||
- Design and planning
|
||||
- Implementation
|
||||
- Testing
|
||||
- Documentation
|
||||
|
||||
3. **Custom Workflows**
|
||||
- Create custom workflow templates
|
||||
- Define steps, dependencies, and agents
|
||||
- Configure parallel execution groups
|
||||
|
||||
## Resource Management
|
||||
|
||||
### Resource Pools
|
||||
|
||||
- **Compute**: CPU and processing resources
|
||||
- **Memory**: Memory allocation and usage
|
||||
- **Network**: Network bandwidth and connections
|
||||
- **Agents**: Agent availability and allocation
|
||||
|
||||
### Optimization Strategies
|
||||
|
||||
- **Performance**: Maximum speed and parallelism
|
||||
- **Balanced**: Optimal resource utilization
|
||||
- **Conservative**: Stability and efficiency
|
||||
- **Development**: Development workflow optimization
|
||||
- **Testing**: Testing and validation focus
|
||||
|
||||
## Configuration
|
||||
|
||||
### Orchestration Config
|
||||
|
||||
```typescript
|
||||
const config = {
|
||||
maxParallelAgents: 10, // Maximum parallel agent execution
|
||||
taskTimeout: 300000, // Task timeout in milliseconds (5 minutes)
|
||||
retryAttempts: 3, // Number of retry attempts
|
||||
skillMatchingThreshold: 0.7, // Minimum skill match score
|
||||
resourceAllocation: 'dynamic', // Resource allocation strategy
|
||||
};
|
||||
```
|
||||
|
||||
### Performance Thresholds
|
||||
|
||||
```typescript
|
||||
const thresholds = {
|
||||
cpuUsage: { warning: 70, critical: 90, action: 'scale-up' },
|
||||
memoryUsage: { warning: 80, critical: 95, action: 'scale-up' },
|
||||
queueSize: { warning: 5, critical: 15, action: 'scale-up' },
|
||||
throughput: { warning: 0.3, critical: 0.1, action: 'rebalance' },
|
||||
};
|
||||
```
|
||||
|
||||
## Monitoring & Analytics
|
||||
|
||||
### System Status
|
||||
|
||||
```typescript
|
||||
const status = orchestrator.getSystemStatus();
|
||||
console.log('Active agents:', status.agents.length);
|
||||
console.log('Active tasks:', status.activeTasks.length);
|
||||
console.log('Queued tasks:', status.queuedTasks.length);
|
||||
console.log('System metrics:', status.metrics);
|
||||
```
|
||||
|
||||
### Performance Monitoring
|
||||
|
||||
```typescript
|
||||
// Workflow execution monitoring
|
||||
const monitoring =
|
||||
await orchestrationSkill.monitorWorkflowExecution(workflowId);
|
||||
console.log('Progress:', monitoring.progress);
|
||||
console.log('Bottlenecks:', monitoring.bottlenecks);
|
||||
|
||||
// Resource utilization
|
||||
const utilization = optimizer.getResourceUtilization();
|
||||
console.log('Overall status:', utilization.overallStatus);
|
||||
```
|
||||
|
||||
## Development
|
||||
|
||||
### Building
|
||||
|
||||
```bash
|
||||
bun run build
|
||||
```
|
||||
|
||||
### Testing
|
||||
|
||||
```bash
|
||||
bun test
|
||||
```
|
||||
|
||||
### Linting
|
||||
|
||||
```bash
|
||||
bun run lint
|
||||
```
|
||||
|
||||
### Type Checking
|
||||
|
||||
```bash
|
||||
bun run type-check
|
||||
```
|
||||
|
||||
## Integration
|
||||
|
||||
The Orchestrator Agent integrates seamlessly with:
|
||||
|
||||
- **Studio-CC Plugin Manager**: Plugin lifecycle management
|
||||
- **Agent Manager**: Agent discovery and configuration
|
||||
- **MCP Servers**: External service coordination
|
||||
- **Skill Registry**: Skill discovery and matching
|
||||
|
||||
## Best Practices
|
||||
|
||||
### Task Planning
|
||||
|
||||
1. Define clear task requirements and dependencies
|
||||
2. Specify required skills and tools explicitly
|
||||
3. Set appropriate priority levels
|
||||
4. Break complex tasks into smaller, manageable steps
|
||||
|
||||
### Resource Management
|
||||
|
||||
1. Monitor resource utilization regularly
|
||||
2. Set appropriate performance thresholds
|
||||
3. Use optimization strategies based on workload
|
||||
4. Balance between performance and resource efficiency
|
||||
|
||||
### Workflow Design
|
||||
|
||||
1. Create reusable workflow templates
|
||||
2. Define parallel execution groups where possible
|
||||
3. Set realistic time estimates
|
||||
4. Include error handling and retry logic
|
||||
|
||||
## License
|
||||
|
||||
MIT License - see LICENSE file for details.
|
||||
|
||||
## Contributing
|
||||
|
||||
Contributions are welcome! Please ensure all code follows the project's ESLint rules and includes appropriate tests.
|
||||
466
agents/orchestrator/SKILL.md
Normal file
466
agents/orchestrator/SKILL.md
Normal file
@@ -0,0 +1,466 @@
|
||||
---
|
||||
name: orchestrator-agent
|
||||
description: Advanced orchestration agent for managing subagents, commands, MCP servers, and skills with parallel execution capabilities
|
||||
category: automation
|
||||
tags: [orchestration, agent-management, task-planning, parallel-execution, resource-optimization]
|
||||
triggers:
|
||||
- type: keyword
|
||||
pattern: "orchestrat"
|
||||
priority: 3
|
||||
- type: keyword
|
||||
pattern: "manage agents"
|
||||
priority: 3
|
||||
- type: keyword
|
||||
pattern: "agent management"
|
||||
priority: 3
|
||||
- type: keyword
|
||||
pattern: "coordinate multiple"
|
||||
priority: 3
|
||||
- type: keyword
|
||||
pattern: "coordinate agents"
|
||||
priority: 3
|
||||
- type: keyword
|
||||
pattern: "task planning"
|
||||
priority: 2
|
||||
- type: keyword
|
||||
pattern: "workflow planning"
|
||||
priority: 2
|
||||
- type: keyword
|
||||
pattern: "parallel execution"
|
||||
priority: 2
|
||||
- type: keyword
|
||||
pattern: "simultaneous tasks"
|
||||
priority: 2
|
||||
- type: keyword
|
||||
pattern: "resource optimization"
|
||||
priority: 2
|
||||
- type: keyword
|
||||
pattern: "discover agents"
|
||||
priority: 3
|
||||
- type: keyword
|
||||
pattern: "find agents"
|
||||
priority: 3
|
||||
|
||||
parameters:
|
||||
- name: action
|
||||
type: string
|
||||
description: The orchestration action to perform
|
||||
required: true
|
||||
validation:
|
||||
pattern: "^(create-task|execute-task|manage-agents|optimize-resources|discover-components|plan-workflow|monitor-execution)$"
|
||||
message: "Action must be one of: create-task, execute-task, manage-agents, optimize-resources, discover-components, plan-workflow, monitor-execution"
|
||||
|
||||
- name: task_description
|
||||
type: string
|
||||
description: Description of the task to orchestrate
|
||||
required: false
|
||||
validation:
|
||||
minLength: 10
|
||||
message: "Task description must be at least 10 characters long"
|
||||
|
||||
- name: agents
|
||||
type: array
|
||||
description: List of agents to involve in orchestration
|
||||
required: false
|
||||
items:
|
||||
type: string
|
||||
|
||||
- name: priority
|
||||
type: number
|
||||
description: Task priority (1-10)
|
||||
required: false
|
||||
default: 5
|
||||
validation:
|
||||
minimum: 1
|
||||
maximum: 10
|
||||
|
||||
- name: parallel_execution
|
||||
type: boolean
|
||||
description: Enable parallel execution when possible
|
||||
required: false
|
||||
default: true
|
||||
|
||||
allowed-tools:
|
||||
- Read
|
||||
- Write
|
||||
- Edit
|
||||
- Bash
|
||||
- Glob
|
||||
- Grep
|
||||
- WebFetch
|
||||
- Task
|
||||
|
||||
triggers:
|
||||
- "orchestrate task execution"
|
||||
- "manage multiple agents"
|
||||
- "plan complex workflow"
|
||||
- "optimize resource allocation"
|
||||
- "coordinate parallel execution"
|
||||
- "discover available agents"
|
||||
- "monitor task progress"
|
||||
- "allocate skills to tasks"
|
||||
|
||||
examples:
|
||||
- input: "Create task plan for security audit with parallel execution"
|
||||
output: "Created task plan with 5 subtasks optimized for parallel execution using security-specialized agents"
|
||||
- input: "Discover all available agents and their capabilities"
|
||||
output: "Discovered 23 agents with detailed capability mapping and performance metrics"
|
||||
- input: "Execute workflow for code review with multiple agents"
|
||||
output: "Coordinated 3 agents (code-reviewer, security-analyzer, documentation-reviewer) in parallel for comprehensive review"
|
||||
|
||||
requirements:
|
||||
- "Node.js 18+ for agent coordination"
|
||||
- "Sufficient memory for parallel agent execution"
|
||||
- "Network connectivity for agent discovery"
|
||||
- "Write permissions for task management"
|
||||
|
||||
limitations:
|
||||
- "Maximum parallel agents: 10"
|
||||
- "Task timeout: 5 minutes"
|
||||
- "Maximum concurrent workflows: 5"
|
||||
- "Skill matching threshold: 0.7"
|
||||
---
|
||||
|
||||
# Orchestrator Agent
|
||||
|
||||
## Overview
|
||||
|
||||
The Orchestrator Agent is an advanced coordination system for managing Claude Code agents, commands, MCP servers, and skills. It provides intelligent task planning, parallel execution optimization, and resource management capabilities.
|
||||
|
||||
## When to Use This Agent
|
||||
|
||||
Use this agent when you need to:
|
||||
|
||||
- Coordinate multiple agents for complex tasks
|
||||
- Plan and execute multi-step workflows
|
||||
- Optimize resource allocation and parallel execution
|
||||
- Discover and analyze available agents and skills
|
||||
- Monitor and manage task execution
|
||||
- Allocate skills to specific tasks intelligently
|
||||
- Handle complex dependency chains
|
||||
|
||||
## Capabilities
|
||||
|
||||
### Task Planning and Execution
|
||||
|
||||
- Create comprehensive task plans with dependencies
|
||||
- Execute tasks in parallel when possible
|
||||
- Handle task priorities and deadlines
|
||||
- Manage task lifecycles from creation to completion
|
||||
- Automatic retry and error recovery
|
||||
|
||||
### Agent Management
|
||||
|
||||
- Discover available agents dynamically
|
||||
- Track agent performance and capabilities
|
||||
- Coordinate agent selection for specific tasks
|
||||
- Monitor agent availability and status
|
||||
- Load balancing across multiple agents
|
||||
|
||||
### Resource Optimization
|
||||
|
||||
- Dynamic resource allocation based on workload
|
||||
- Performance monitoring and bottleneck detection
|
||||
- Automatic scaling and optimization
|
||||
- Resource pool management
|
||||
- Conflict resolution and prioritization
|
||||
|
||||
### Skill Allocation
|
||||
|
||||
- Intelligent skill-to-task matching
|
||||
- Skill dependency analysis
|
||||
- Performance-based skill selection
|
||||
- Real-time skill availability tracking
|
||||
- Cross-agent skill coordination
|
||||
|
||||
## Usage Examples
|
||||
|
||||
### Basic Task Orchestration
|
||||
|
||||
```typescript
|
||||
import OrchestratorAgent from './index';
|
||||
|
||||
const orchestrator = new OrchestratorAgent({
|
||||
maxParallelAgents: 5,
|
||||
skillMatchingThreshold: 0.8,
|
||||
});
|
||||
|
||||
await orchestrator.initialize();
|
||||
|
||||
// Create task plan
|
||||
const taskId = await orchestrator.createTaskPlan('Code review project', {
|
||||
requiredSkills: ['code-review', 'security-analysis'],
|
||||
priority: 1,
|
||||
parallelExecution: true,
|
||||
});
|
||||
|
||||
// Execute task
|
||||
await orchestrator.executeTask(taskId);
|
||||
```
|
||||
|
||||
### Advanced Workflow Management
|
||||
|
||||
```typescript
|
||||
// Discover available agents
|
||||
const agents = orchestrator.getAvailableAgents();
|
||||
|
||||
// Plan complex workflow
|
||||
const workflowId = await orchestrator.planWorkflow({
|
||||
name: 'Feature development pipeline',
|
||||
steps: [
|
||||
{ name: 'requirements-analysis', agents: ['general-purpose'] },
|
||||
{ name: 'architecture-design', agents: ['feature-dev:code-architect'] },
|
||||
{ name: 'implementation', agents: ['general-purpose'], parallel: true },
|
||||
{ name: 'testing', agents: ['general-purpose'], parallel: true },
|
||||
{ name: 'documentation', agents: ['pr-review-toolkit:comment-analyzer'] },
|
||||
],
|
||||
dependencies: {
|
||||
'architecture-design': ['requirements-analysis'],
|
||||
implementation: ['architecture-design'],
|
||||
testing: ['implementation'],
|
||||
documentation: ['testing'],
|
||||
},
|
||||
});
|
||||
|
||||
// Execute workflow
|
||||
await orchestrator.executeWorkflow(workflowId);
|
||||
```
|
||||
|
||||
### Resource Optimization
|
||||
|
||||
```typescript
|
||||
// Optimize resource allocation
|
||||
const optimization = await orchestrator.optimizeResources();
|
||||
console.log('Optimizations applied:', optimization.optimizations);
|
||||
console.log('Recommendations:', optimization.recommendations);
|
||||
|
||||
// Monitor performance
|
||||
const status = orchestrator.getSystemStatus();
|
||||
console.log('Active tasks:', status.activeTasks.length);
|
||||
console.log(
|
||||
'Agent utilization:',
|
||||
status.agents.filter((a) => a.status === 'busy').length
|
||||
);
|
||||
```
|
||||
|
||||
## Configuration
|
||||
|
||||
### Basic Configuration
|
||||
|
||||
```typescript
|
||||
const orchestrator = new OrchestratorAgent({
|
||||
maxParallelAgents: 10,
|
||||
taskTimeout: 300000,
|
||||
retryAttempts: 3,
|
||||
skillMatchingThreshold: 0.7,
|
||||
resourceAllocation: 'dynamic',
|
||||
});
|
||||
```
|
||||
|
||||
### Advanced Configuration
|
||||
|
||||
```typescript
|
||||
const orchestrator = new OrchestratorAgent({
|
||||
maxParallelAgents: 15,
|
||||
taskTimeout: 600000,
|
||||
retryAttempts: 5,
|
||||
skillMatchingThreshold: 0.8,
|
||||
resourceAllocation: 'performance',
|
||||
discoveryInterval: 60000,
|
||||
optimizationStrategy: 'aggressive',
|
||||
monitoring: {
|
||||
enableMetrics: true,
|
||||
enableLogging: true,
|
||||
logLevel: 'info',
|
||||
},
|
||||
});
|
||||
```
|
||||
|
||||
## Discovery System
|
||||
|
||||
The orchestrator includes a dynamic discovery system that:
|
||||
|
||||
### Agent Discovery
|
||||
|
||||
- Scans for available agents automatically
|
||||
- Tracks agent capabilities and performance
|
||||
- Updates agent availability in real-time
|
||||
- Maintains performance metrics and statistics
|
||||
|
||||
### Skill Discovery
|
||||
|
||||
- Discovers available skills across all agents
|
||||
- Categorizes and indexes skills by function
|
||||
- Tracks skill dependencies and compatibility
|
||||
- Monitors skill performance and reliability
|
||||
|
||||
### MCP Server Discovery
|
||||
|
||||
- Identifies available MCP servers
|
||||
- Tracks server capabilities and endpoints
|
||||
- Monitors server health and availability
|
||||
- Handles server failover and recovery
|
||||
|
||||
## Performance Optimization
|
||||
|
||||
### Parallel Execution
|
||||
|
||||
- Automatically identifies parallelizable tasks
|
||||
- Coordinates simultaneous agent execution
|
||||
- Manages resource contention and conflicts
|
||||
- Optimizes execution order for maximum efficiency
|
||||
|
||||
### Load Balancing
|
||||
|
||||
- Distributes tasks across available agents
|
||||
- Considers agent performance and availability
|
||||
- Handles agent failures and retries
|
||||
- Maintains optimal resource utilization
|
||||
|
||||
### Caching and Optimization
|
||||
|
||||
- Caches agent capabilities and performance data
|
||||
- Optimizes frequently used task patterns
|
||||
- Reduces discovery overhead
|
||||
- Improves response times for common operations
|
||||
|
||||
## Monitoring and Analytics
|
||||
|
||||
### Task Monitoring
|
||||
|
||||
- Real-time task progress tracking
|
||||
- Performance metrics and analytics
|
||||
- Error detection and recovery
|
||||
- Completion time predictions
|
||||
|
||||
### Agent Performance
|
||||
|
||||
- Success rate tracking
|
||||
- Average execution time monitoring
|
||||
- Resource usage analysis
|
||||
- Bottleneck identification
|
||||
|
||||
### System Health
|
||||
|
||||
- Overall system status monitoring
|
||||
- Resource utilization tracking
|
||||
- Performance trend analysis
|
||||
- Capacity planning recommendations
|
||||
|
||||
## Best Practices
|
||||
|
||||
### Task Planning
|
||||
|
||||
1. Break complex tasks into smaller, manageable steps
|
||||
2. Define clear dependencies and requirements
|
||||
3. Set appropriate priorities and deadlines
|
||||
4. Consider parallel execution opportunities
|
||||
5. Plan for error handling and recovery
|
||||
|
||||
### Resource Management
|
||||
|
||||
1. Monitor resource utilization regularly
|
||||
2. Set appropriate concurrency limits
|
||||
3. Optimize agent selection based on capabilities
|
||||
4. Use performance data to inform decisions
|
||||
5. Plan for peak loads and scaling
|
||||
|
||||
### Error Handling
|
||||
|
||||
1. Implement comprehensive error detection
|
||||
2. Use appropriate retry strategies
|
||||
3. Provide fallback mechanisms
|
||||
4. Monitor and analyze error patterns
|
||||
5. Continuously improve error handling
|
||||
|
||||
## Integration
|
||||
|
||||
### With Plugins
|
||||
|
||||
The orchestrator works seamlessly with marketplace plugins:
|
||||
|
||||
- Discovers plugin-provided agents automatically
|
||||
- Integrates with plugin configuration systems
|
||||
- Respects plugin permissions and limitations
|
||||
- Supports plugin-specific optimization strategies
|
||||
|
||||
### With Skills
|
||||
|
||||
- Coordinates skill execution across agents
|
||||
- Manages skill dependencies and conflicts
|
||||
- Optimizes skill allocation based on performance
|
||||
- Tracks skill usage and effectiveness
|
||||
|
||||
### With MCP Servers
|
||||
|
||||
- Coordinates MCP server operations
|
||||
- Manages server resources and connections
|
||||
- Handles server failover and recovery
|
||||
- Optimizes server usage patterns
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
### Common Issues
|
||||
|
||||
1. **Agents Not Discovered**: Check agent configurations and permissions
|
||||
2. **Task Execution Failures**: Review task dependencies and requirements
|
||||
3. **Performance Issues**: Monitor resource utilization and bottlenecks
|
||||
4. **Parallel Execution Problems**: Verify task independence and resource availability
|
||||
|
||||
### Debug Information
|
||||
|
||||
Enable detailed logging for troubleshooting:
|
||||
|
||||
```typescript
|
||||
const orchestrator = new OrchestratorAgent({
|
||||
monitoring: {
|
||||
enableLogging: true,
|
||||
logLevel: 'debug',
|
||||
},
|
||||
});
|
||||
```
|
||||
|
||||
### Performance Monitoring
|
||||
|
||||
Use built-in monitoring tools:
|
||||
|
||||
```typescript
|
||||
// Get system status
|
||||
const status = orchestrator.getSystemStatus();
|
||||
|
||||
// Get discovery status
|
||||
const discoveryStatus = orchestrator.getDiscoveryStatus();
|
||||
|
||||
// Get performance metrics
|
||||
const metrics = orchestrator.getPerformanceMetrics();
|
||||
```
|
||||
|
||||
## Version History
|
||||
|
||||
### v1.0.0 (2025-11-03)
|
||||
|
||||
- Initial release with comprehensive orchestration capabilities
|
||||
- Dynamic agent and skill discovery system
|
||||
- Parallel execution optimization
|
||||
- Resource management and monitoring
|
||||
- Performance analytics and optimization
|
||||
|
||||
## Support and Resources
|
||||
|
||||
### Documentation
|
||||
|
||||
- Complete API reference and usage examples
|
||||
- Configuration guides and best practices
|
||||
- Troubleshooting guides and FAQ
|
||||
- Integration documentation
|
||||
|
||||
### Community Resources
|
||||
|
||||
- GitHub repository for issues and contributions
|
||||
- Community discussions and support
|
||||
- Example implementations and patterns
|
||||
- Performance tuning guides
|
||||
|
||||
---
|
||||
|
||||
_This orchestrator agent provides comprehensive coordination and optimization capabilities for complex multi-agent workflows in Claude Code._
|
||||
51
agents/orchestrator/agent-config.json
Normal file
51
agents/orchestrator/agent-config.json
Normal file
@@ -0,0 +1,51 @@
|
||||
{
|
||||
"name": "orchestrator",
|
||||
"description": "Advanced orchestration agent for managing subagents, commands, MCP servers, and skills with parallel execution capabilities",
|
||||
"version": "1.0.0",
|
||||
"model": "claude-sonnet-4-5",
|
||||
"template": "expert",
|
||||
"specialization": "orchestration",
|
||||
"permissions": "admin",
|
||||
"context_window": 200000,
|
||||
"temperature": 0.2,
|
||||
"max_tokens": 8000,
|
||||
"skills": [
|
||||
"agent-creator",
|
||||
"claude-code-plugin",
|
||||
"claude-code-marketplace",
|
||||
"mcp-creator",
|
||||
"prompt",
|
||||
"claude-code-agent-manager"
|
||||
],
|
||||
"tools": ["file", "bash", "web-search", "browser", "database", "Task"],
|
||||
"response_format": "detailed",
|
||||
"capabilities": {
|
||||
"subagent_management": true,
|
||||
"command_execution": true,
|
||||
"mcp_coordination": true,
|
||||
"skill_allocation": true,
|
||||
"parallel_execution": true,
|
||||
"task_planning": true,
|
||||
"resource_optimization": true
|
||||
},
|
||||
"skills_priority": {
|
||||
"analysis": 1,
|
||||
"planning": 2,
|
||||
"coordination": 3,
|
||||
"execution": 4,
|
||||
"monitoring": 5
|
||||
},
|
||||
"orchestration_config": {
|
||||
"max_parallel_agents": 10,
|
||||
"task_timeout": 300000,
|
||||
"retry_attempts": 3,
|
||||
"skill_matching_threshold": 0.7,
|
||||
"resource_allocation": "dynamic"
|
||||
},
|
||||
"managed_components": {
|
||||
"subagents": ["all"],
|
||||
"commands": ["all"],
|
||||
"mcp_servers": ["all"],
|
||||
"skills": ["all"]
|
||||
}
|
||||
}
|
||||
630
agents/orchestrator/dynamic-discovery.ts
Normal file
630
agents/orchestrator/dynamic-discovery.ts
Normal file
@@ -0,0 +1,630 @@
|
||||
/**
|
||||
* Dynamic Discovery System for Orchestrator
|
||||
* Enables real-time discovery of agents, skills, commands, and MCP servers
|
||||
*/
|
||||
|
||||
import { AgentCapability } from './index';
|
||||
|
||||
export interface DiscoverySource {
|
||||
name: string;
|
||||
type: 'agents' | 'skills' | 'commands' | 'mcp';
|
||||
endpoint?: string;
|
||||
refreshInterval: number;
|
||||
lastUpdate: Date;
|
||||
}
|
||||
|
||||
export interface DiscoveryResult<T> {
|
||||
items: T[];
|
||||
timestamp: Date;
|
||||
source: string;
|
||||
errors?: string[];
|
||||
}
|
||||
|
||||
/**
|
||||
* Dynamic Discovery System for the Orchestrator.
|
||||
*
|
||||
* Enables real-time discovery of agents, skills, commands, and MCP servers
|
||||
* through multiple discovery sources including file system scanning,
|
||||
* API queries, and plugin discovery.
|
||||
*/
|
||||
export class DynamicDiscoverySystem {
|
||||
private discoverySources: Map<string, DiscoverySource> = new Map();
|
||||
private cache: Map<string, { data: unknown; timestamp: Date; ttl: number }> =
|
||||
new Map();
|
||||
private refreshTimers: Map<string, NodeJS.Timeout> = new Map();
|
||||
|
||||
/**
|
||||
* Creates a new instance of the DynamicDiscoverySystem.
|
||||
*
|
||||
* Initializes discovery sources and starts automatic refresh timers.
|
||||
*/
|
||||
constructor() {
|
||||
this.initializeDiscoverySources();
|
||||
this.startAutoRefresh();
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize all discovery sources
|
||||
*/
|
||||
private initializeDiscoverySources(): void {
|
||||
// Claude Code agents discovery
|
||||
this.discoverySources.set('claude-agents', {
|
||||
name: 'Claude Code Agents',
|
||||
type: 'agents',
|
||||
refreshInterval: 300000, // 5 minutes
|
||||
lastUpdate: new Date(0),
|
||||
});
|
||||
|
||||
// Skills discovery from skill registry
|
||||
this.discoverySources.set('skill-registry', {
|
||||
name: 'Skill Registry',
|
||||
type: 'skills',
|
||||
refreshInterval: 600000, // 10 minutes
|
||||
lastUpdate: new Date(0),
|
||||
});
|
||||
|
||||
// Commands discovery
|
||||
this.discoverySources.set('command-registry', {
|
||||
name: 'Command Registry',
|
||||
type: 'commands',
|
||||
refreshInterval: 300000, // 5 minutes
|
||||
lastUpdate: new Date(0),
|
||||
});
|
||||
|
||||
// MCP servers discovery
|
||||
this.discoverySources.set('mcp-registry', {
|
||||
name: 'MCP Server Registry',
|
||||
type: 'mcp',
|
||||
refreshInterval: 600000, // 10 minutes
|
||||
lastUpdate: new Date(0),
|
||||
});
|
||||
|
||||
// Plugin-based agents discovery
|
||||
this.discoverySources.set('plugin-agents', {
|
||||
name: 'Plugin Agents',
|
||||
type: 'agents',
|
||||
refreshInterval: 300000, // 5 minutes
|
||||
lastUpdate: new Date(0),
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Start automatic refresh for all sources
|
||||
*/
|
||||
private startAutoRefresh(): void {
|
||||
for (const [id, source] of this.discoverySources) {
|
||||
this.scheduleRefresh(id, source);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Schedule refresh for a specific source.
|
||||
*
|
||||
* @param id - The unique identifier for the discovery source
|
||||
* @param source - The discovery source configuration
|
||||
*/
|
||||
private scheduleRefresh(id: string, source: DiscoverySource): void {
|
||||
const timer = setInterval(async () => {
|
||||
try {
|
||||
await this.refreshSource(id);
|
||||
} catch (error) {
|
||||
console.error(`Failed to refresh source ${id}:`, error);
|
||||
}
|
||||
}, source.refreshInterval);
|
||||
|
||||
this.refreshTimers.set(id, timer);
|
||||
}
|
||||
|
||||
/**
|
||||
* Refresh a specific discovery source.
|
||||
*
|
||||
* @param id - The unique identifier for the discovery source
|
||||
*/
|
||||
async refreshSource(id: string): Promise<void> {
|
||||
const source = this.discoverySources.get(id);
|
||||
if (!source) {
|
||||
throw new Error(`Discovery source ${id} not found`);
|
||||
}
|
||||
|
||||
const cacheKey = `${source.type}:${id}`;
|
||||
const cached = this.cache.get(cacheKey);
|
||||
|
||||
// Check if cache is still valid
|
||||
if (cached && Date.now() - cached.timestamp.getTime() < cached.ttl) {
|
||||
return; // Cache is still valid
|
||||
}
|
||||
|
||||
let result: unknown;
|
||||
|
||||
switch (source.type) {
|
||||
case 'agents':
|
||||
result = await this.discoverAgents(source);
|
||||
break;
|
||||
case 'skills':
|
||||
result = await this.discoverSkills(source);
|
||||
break;
|
||||
case 'commands':
|
||||
result = await this.discoverCommands(source);
|
||||
break;
|
||||
case 'mcp':
|
||||
result = await this.discoverMCPServers(source);
|
||||
break;
|
||||
default:
|
||||
throw new Error(`Unknown discovery type: ${source.type}`);
|
||||
}
|
||||
|
||||
// Update cache
|
||||
this.cache.set(cacheKey, {
|
||||
data: Array.isArray(result) ? result : [result],
|
||||
timestamp: new Date(),
|
||||
ttl: source.refreshInterval * 0.8, // Cache for 80% of refresh interval
|
||||
});
|
||||
|
||||
source.lastUpdate = new Date();
|
||||
}
|
||||
|
||||
/**
|
||||
* Discover agents dynamically from various sources.
|
||||
*
|
||||
* @param source - The discovery source configuration
|
||||
* @returns Array of discovered agent capabilities
|
||||
*/
|
||||
private async discoverAgents(
|
||||
source: DiscoverySource
|
||||
): Promise<AgentCapability[]> {
|
||||
const agents: AgentCapability[] = [];
|
||||
|
||||
try {
|
||||
// Method 1: Scan for agent files
|
||||
const fileSystemAgents = await this.scanFileSystemForAgents();
|
||||
agents.push(...fileSystemAgents);
|
||||
|
||||
// Method 2: Query Claude Code API (if available)
|
||||
const apiAgents = await this.queryClaudeCodeAPI('agents');
|
||||
agents.push(...apiAgents);
|
||||
|
||||
// Method 3: Check for plugin agents
|
||||
const pluginAgents = await this.discoverPluginAgents();
|
||||
agents.push(...pluginAgents);
|
||||
|
||||
// Method 4: Discover runtime agents
|
||||
const runtimeAgents = await this.discoverRuntimeAgents();
|
||||
agents.push(...runtimeAgents);
|
||||
} catch (error) {
|
||||
console.error(`Error discovering agents from ${source.name}:`, error);
|
||||
}
|
||||
|
||||
return agents;
|
||||
}
|
||||
|
||||
/**
|
||||
* Discover skills dynamically from various sources.
|
||||
*
|
||||
* @param source - The discovery source configuration
|
||||
* @returns Array of discovered skill names
|
||||
*/
|
||||
private async discoverSkills(source: DiscoverySource): Promise<string[]> {
|
||||
const skills: string[] = [];
|
||||
|
||||
try {
|
||||
// Method 1: Scan skill files
|
||||
const fileSystemSkills = await this.scanFileSystemForSkills();
|
||||
skills.push(...fileSystemSkills);
|
||||
|
||||
// Method 2: Query skill registry
|
||||
const registrySkills = await this.querySkillRegistry();
|
||||
skills.push(...registrySkills);
|
||||
|
||||
// Method 3: Discover plugin skills
|
||||
const pluginSkills = await this.discoverPluginSkills();
|
||||
skills.push(...pluginSkills);
|
||||
} catch (error) {
|
||||
console.error(`Error discovering skills from ${source.name}:`, error);
|
||||
}
|
||||
|
||||
return [...new Set(skills)]; // Remove duplicates
|
||||
}
|
||||
|
||||
/**
|
||||
* Discover commands dynamically from various sources.
|
||||
*
|
||||
* @param source - The discovery source configuration
|
||||
* @returns Array of discovered command names
|
||||
*/
|
||||
private async discoverCommands(source: DiscoverySource): Promise<string[]> {
|
||||
const commands: string[] = [];
|
||||
|
||||
try {
|
||||
// Method 1: Scan for slash command files
|
||||
const fileSystemCommands = await this.scanFileSystemForCommands();
|
||||
commands.push(...fileSystemCommands);
|
||||
|
||||
// Method 2: Query command registry
|
||||
const registryCommands = await this.queryCommandRegistry();
|
||||
commands.push(...registryCommands);
|
||||
|
||||
// Method 3: Discover plugin commands
|
||||
const pluginCommands = await this.discoverPluginCommands();
|
||||
commands.push(...pluginCommands);
|
||||
} catch (error) {
|
||||
console.error(`Error discovering commands from ${source.name}:`, error);
|
||||
}
|
||||
|
||||
return [...new Set(commands)]; // Remove duplicates
|
||||
}
|
||||
|
||||
/**
|
||||
* Discover MCP servers dynamically from various sources.
|
||||
*
|
||||
* @param source - The discovery source configuration
|
||||
* @returns Array of discovered MCP server names
|
||||
*/
|
||||
private async discoverMCPServers(source: DiscoverySource): Promise<string[]> {
|
||||
const mcpServers: string[] = [];
|
||||
|
||||
try {
|
||||
// Method 1: Scan for MCP configurations
|
||||
const configMCPServers = await this.scanMCPConfigurations();
|
||||
mcpServers.push(...configMCPServers);
|
||||
|
||||
// Method 2: Query MCP registry
|
||||
const registryMCPServers = await this.queryMCPRegistry();
|
||||
mcpServers.push(...registryMCPServers);
|
||||
|
||||
// Method 3: Discover running MCP servers
|
||||
const runningMCPServers = await this.discoverRunningMCPServers();
|
||||
mcpServers.push(...runningMCPServers);
|
||||
} catch (error) {
|
||||
console.error(
|
||||
`Error discovering MCP servers from ${source.name}:`,
|
||||
error
|
||||
);
|
||||
}
|
||||
|
||||
return [...new Set(mcpServers)]; // Remove duplicates
|
||||
}
|
||||
|
||||
/**
|
||||
* Scan file system for agents
|
||||
*/
|
||||
private async scanFileSystemForAgents(): Promise<AgentCapability[]> {
|
||||
const agents: AgentCapability[] = [];
|
||||
|
||||
try {
|
||||
// This would scan the agents directory for agent definitions
|
||||
// For now, return the static list as fallback
|
||||
const staticAgents = [
|
||||
'general-purpose',
|
||||
'statusline-setup',
|
||||
'Explore',
|
||||
'Plan',
|
||||
'superpowers:code-reviewer',
|
||||
'episodic-memory:search-conversations',
|
||||
'agent-sdk-dev:agent-sdk-verifier-py',
|
||||
'agent-sdk-dev:agent-sdk-verifier-ts',
|
||||
'pr-review-toolkit:code-reviewer',
|
||||
'pr-review-toolkit:code-simplifier',
|
||||
'pr-review-toolkit:comment-analyzer',
|
||||
'pr-review-toolkit:pr-test-analyzer',
|
||||
'pr-review-toolkit:silent-failure-hunter',
|
||||
'pr-review-toolkit:type-design-analyzer',
|
||||
'feature-dev:code-architect',
|
||||
'feature-dev:code-explorer',
|
||||
'feature-dev:code-reviewer',
|
||||
'studio-cc:cc-expert-examples',
|
||||
'studio-cc:cc-expert',
|
||||
'astrojs-specialist',
|
||||
'agent-creator',
|
||||
'lint-typescript-fixer',
|
||||
];
|
||||
|
||||
for (const agentType of staticAgents) {
|
||||
agents.push({
|
||||
name: agentType,
|
||||
skills: await this.getAgentSkillsFromFile(agentType),
|
||||
tools: await this.getAgentToolsFromFile(agentType),
|
||||
status: 'inactive',
|
||||
performance: {
|
||||
successRate: 1.0,
|
||||
avgExecutionTime: 0,
|
||||
lastUsed: new Date(),
|
||||
},
|
||||
});
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Error scanning file system for agents:', error);
|
||||
}
|
||||
|
||||
return agents;
|
||||
}
|
||||
|
||||
private readonly AVAILABLE_SKILLS = [
|
||||
'n8n-code-javascript',
|
||||
'n8n-code-python',
|
||||
'n8n-expression-syntax',
|
||||
'n8n-mcp-tools-expert',
|
||||
'n8n-node-configuration',
|
||||
'n8n-validation-expert',
|
||||
'n8n-workflow-patterns',
|
||||
'superpowers:brainstorming',
|
||||
'superpowers:condition-based-waiting',
|
||||
'superpowers:defense-in-depth',
|
||||
'superpowers:dispatching-parallel-agents',
|
||||
'superpowers:executing-plans',
|
||||
'superpowers:finishing-a-development-branch',
|
||||
'superpowers:receiving-code-review',
|
||||
'superpowers:requesting-code-review',
|
||||
'superpowers:root-cause-tracing',
|
||||
'superpowers:sharing-skills',
|
||||
'superpowers:subagent-driven-development',
|
||||
'superpowers:systematic-debugging',
|
||||
'superpowers:test-driven-development',
|
||||
'superpowers:testing-anti-patterns',
|
||||
'example-skills:kokoro-js-builder',
|
||||
'example-skills:kokoro-tts-builder',
|
||||
'example-skills:nodejs-cli-builder',
|
||||
'example-skills:python-cli-builder',
|
||||
'example-skills:skill-creator',
|
||||
'example-skills:mcp-builder',
|
||||
'example-skills:canvas-design',
|
||||
'example-skills:algorithmic-art',
|
||||
'example-skills:internal-comms',
|
||||
'example-skills:webapp-testing',
|
||||
'example-skills:artifacts-builder',
|
||||
'example-skills:slack-gif-creator',
|
||||
'example-skills:theme-factory',
|
||||
'example-skills:brand-guidelines',
|
||||
'superpowers-chrome:browsing',
|
||||
];
|
||||
|
||||
/**
|
||||
* Scan file system for skills
|
||||
*/
|
||||
private async scanFileSystemForSkills(): Promise<string[]> {
|
||||
try {
|
||||
return this.AVAILABLE_SKILLS;
|
||||
} catch (error) {
|
||||
console.error('Error scanning file system for skills:', error);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Scan file system for commands
|
||||
*/
|
||||
private async scanFileSystemForCommands(): Promise<string[]> {
|
||||
try {
|
||||
// This would scan for .claude/commands/ directory
|
||||
return [
|
||||
'/superpowers:brainstorm',
|
||||
'/superpowers:execute-plan',
|
||||
'/superpowers:write-plan',
|
||||
'/episodic-memory:search-conversations',
|
||||
'/agent-sdk-dev:new-sdk-app',
|
||||
'/pr-review-toolkit:review-pr',
|
||||
'/commit-commands:clean_gone',
|
||||
'/commit-commands:commit-push-pr',
|
||||
'/commit-commands:commit',
|
||||
'/feature-dev:feature-dev',
|
||||
'/code-review:code-review',
|
||||
'/studio-cc:cc-plugin',
|
||||
];
|
||||
} catch (error) {
|
||||
console.error('Error scanning file system for commands:', error);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Placeholder method for querying Claude Code API.
|
||||
*
|
||||
* @param _type - The type of items to query (agents/skills/commands)
|
||||
* @returns Array of available items from Claude Code API
|
||||
*/
|
||||
private async queryClaudeCodeAPI(_type: string): Promise<unknown[]> {
|
||||
// This would query the Claude Code API for available agents/skills
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Queries a central skill registry for available skills.
|
||||
*
|
||||
* @returns Array of available skill names from the registry
|
||||
*/
|
||||
private async querySkillRegistry(): Promise<string[]> {
|
||||
// This would query a central skill registry
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Queries a central command registry for available commands.
|
||||
*
|
||||
* @returns Array of available command names from the registry
|
||||
*/
|
||||
private async queryCommandRegistry(): Promise<string[]> {
|
||||
// This would query a central command registry
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Queries an MCP server registry for available servers.
|
||||
*
|
||||
* @returns Array of available MCP server names from the registry
|
||||
*/
|
||||
private async queryMCPRegistry(): Promise<string[]> {
|
||||
// This would query an MCP server registry
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Discovers agents from available plugins.
|
||||
*
|
||||
* @returns Array of agent capabilities discovered from plugins
|
||||
*/
|
||||
private async discoverPluginAgents(): Promise<AgentCapability[]> {
|
||||
// This would discover agents from plugins
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Discovers skills from available plugins.
|
||||
*
|
||||
* @returns Array of skill names discovered from plugins
|
||||
*/
|
||||
private async discoverPluginSkills(): Promise<string[]> {
|
||||
// This would discover skills from plugins
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Discovers commands from available plugins.
|
||||
*
|
||||
* @returns Array of command names discovered from plugins
|
||||
*/
|
||||
private async discoverPluginCommands(): Promise<string[]> {
|
||||
// This would discover commands from plugins
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Scans for MCP configuration files.
|
||||
*
|
||||
* @returns Array of MCP server names found in configuration files
|
||||
*/
|
||||
private async scanMCPConfigurations(): Promise<string[]> {
|
||||
// This would scan for MCP configuration files
|
||||
return ['superpowers-chrome', 'web-search-prime', 'zai-mcp-server'];
|
||||
}
|
||||
|
||||
/**
|
||||
* Discovers currently running MCP servers.
|
||||
*
|
||||
* @returns Array of currently running MCP server names
|
||||
*/
|
||||
private async discoverRunningMCPServers(): Promise<string[]> {
|
||||
// This would discover currently running MCP servers
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Discovers agents available at runtime.
|
||||
*
|
||||
* @returns Array of agent capabilities available at runtime
|
||||
*/
|
||||
private async discoverRuntimeAgents(): Promise<AgentCapability[]> {
|
||||
// This would discover agents available at runtime
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads agent skills from file system.
|
||||
*
|
||||
* @param _agentType - The type of agent to read skills for
|
||||
* @returns Array of skill names for the agent
|
||||
*/
|
||||
private async getAgentSkillsFromFile(_agentType: string): Promise<string[]> {
|
||||
// This would read agent skills from file system
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads agent tools from file system.
|
||||
*
|
||||
* @param _agentType - The type of agent to read tools for
|
||||
* @returns Array of tool names for the agent
|
||||
*/
|
||||
private async getAgentToolsFromFile(_agentType: string): Promise<string[]> {
|
||||
// This would read agent tools from file system
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets cached discovery data or refresh if needed.
|
||||
*
|
||||
* @param type - The type of discovery data to retrieve
|
||||
* @param forceRefresh - Whether to force a refresh of the data
|
||||
* @returns Discovery data for the specified type
|
||||
*/
|
||||
async getDiscoveryData(type: string, forceRefresh = false): Promise<unknown> {
|
||||
const sources = Array.from(this.discoverySources.values()).filter(
|
||||
(source) => source.type === type
|
||||
);
|
||||
|
||||
const allData: unknown[] = [];
|
||||
|
||||
for (const source of sources) {
|
||||
if (forceRefresh) {
|
||||
await this.refreshSource(source.name);
|
||||
}
|
||||
|
||||
const cacheKey = `${type}:${source.name}`;
|
||||
const cached = this.cache.get(cacheKey);
|
||||
|
||||
if (cached && Array.isArray(cached.data)) {
|
||||
allData.push(...cached.data);
|
||||
}
|
||||
}
|
||||
|
||||
return allData;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get discovery status
|
||||
*/
|
||||
getDiscoveryStatus(): {
|
||||
sources: Array<{
|
||||
name: string;
|
||||
type: string;
|
||||
lastUpdate: Date;
|
||||
status: 'updated' | 'stale' | 'error';
|
||||
}>;
|
||||
cacheSize: number;
|
||||
} {
|
||||
const sources = Array.from(this.discoverySources.values()).map((source) => {
|
||||
const now = new Date();
|
||||
const age = now.getTime() - source.lastUpdate.getTime();
|
||||
const isStale = age > source.refreshInterval;
|
||||
|
||||
return {
|
||||
name: source.name,
|
||||
type: source.type,
|
||||
lastUpdate: source.lastUpdate,
|
||||
status: isStale
|
||||
? 'stale'
|
||||
: ('updated' as 'updated' | 'stale' | 'error'),
|
||||
};
|
||||
});
|
||||
|
||||
return {
|
||||
sources,
|
||||
cacheSize: this.cache.size,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Force refresh all sources
|
||||
*/
|
||||
async refreshAll(): Promise<void> {
|
||||
for (const [id] of this.discoverySources) {
|
||||
try {
|
||||
await this.refreshSource(id);
|
||||
} catch (error) {
|
||||
console.error(`Failed to refresh source ${id}:`, error);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleanup and stop all refresh timers
|
||||
*/
|
||||
destroy(): void {
|
||||
for (const [, timer] of this.refreshTimers) {
|
||||
clearInterval(timer);
|
||||
}
|
||||
this.refreshTimers.clear();
|
||||
this.cache.clear();
|
||||
this.discoverySources.clear();
|
||||
}
|
||||
}
|
||||
|
||||
export default DynamicDiscoverySystem;
|
||||
194
agents/orchestrator/index.test.ts
Normal file
194
agents/orchestrator/index.test.ts
Normal file
@@ -0,0 +1,194 @@
|
||||
import { test, expect } from 'bun:test';
|
||||
import OrchestrationManagementSkill from './skills/orchestration-management';
|
||||
import ResourceOptimizerSkill from './skills/resource-optimizer';
|
||||
import OrchestratorAgent from './index';
|
||||
|
||||
test('orchestrator initialization', async () => {
|
||||
const orchestrator = new OrchestratorAgent();
|
||||
await orchestrator.initialize();
|
||||
|
||||
expect(orchestrator.name).toBe('orchestrator');
|
||||
expect(orchestrator.version).toBe('1.0.0');
|
||||
|
||||
const status = orchestrator.getSystemStatus();
|
||||
expect(status.agents.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
test('task creation and execution', async () => {
|
||||
const orchestrator = new OrchestratorAgent();
|
||||
await orchestrator.initialize();
|
||||
|
||||
const taskId = await orchestrator.createTaskPlan('Test task', {
|
||||
requiredSkills: ['code-analysis'],
|
||||
priority: 1,
|
||||
});
|
||||
|
||||
expect(taskId).toBeDefined();
|
||||
expect(taskId).toMatch(/^task_\d+_[\da-z]+$/);
|
||||
|
||||
const status = orchestrator.getSystemStatus();
|
||||
// Tasks with no dependencies are auto-executed, so check completed tasks
|
||||
expect(status.completedTasks.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
test('skill discovery and allocation', async () => {
|
||||
const orchestrator = new OrchestratorAgent();
|
||||
await orchestrator.initialize();
|
||||
|
||||
const skills = orchestrator.getAvailableSkills();
|
||||
expect(skills.length).toBeGreaterThan(0);
|
||||
expect(skills).toContain('code-analysis');
|
||||
|
||||
// Create a real task first
|
||||
const taskId = await orchestrator.createTaskPlan('Test task for skills', {
|
||||
requiredSkills: ['code-analysis'],
|
||||
priority: 1,
|
||||
});
|
||||
|
||||
const allocatedSkills = orchestrator.allocateSkillsToTask(taskId, [
|
||||
'code-analysis',
|
||||
'web-search', // Using a skill that exists
|
||||
]);
|
||||
expect(allocatedSkills.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
test('commands and MCP discovery', async () => {
|
||||
const orchestrator = new OrchestratorAgent();
|
||||
await orchestrator.initialize();
|
||||
|
||||
const commands = await orchestrator.getAvailableCommands();
|
||||
expect(commands.length).toBeGreaterThan(0);
|
||||
expect(commands).toContain('/superpowers:brainstorm');
|
||||
|
||||
const mcpServers = await orchestrator.getAvailableMCPServers();
|
||||
expect(mcpServers.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
test('orchestration management skill', async () => {
|
||||
const orchestrator = new OrchestratorAgent();
|
||||
await orchestrator.initialize();
|
||||
|
||||
const orchestrationSkill = new OrchestrationManagementSkill(orchestrator);
|
||||
|
||||
const templates = orchestrationSkill.getWorkflowTemplates();
|
||||
expect(templates.length).toBeGreaterThan(0);
|
||||
expect(templates[0].id).toBeDefined();
|
||||
|
||||
const strategies = orchestrationSkill.getStrategies();
|
||||
expect(strategies.length).toBeGreaterThan(0);
|
||||
expect(strategies[0].name).toBeDefined();
|
||||
});
|
||||
|
||||
test('resource optimizer skill', async () => {
|
||||
const orchestrator = new OrchestratorAgent();
|
||||
await orchestrator.initialize();
|
||||
|
||||
const optimizerSkill = new ResourceOptimizerSkill(orchestrator);
|
||||
|
||||
const optimization = await optimizerSkill.optimizeResources();
|
||||
expect(optimization.optimizations).toBeDefined();
|
||||
expect(optimization.rebalancing).toBeDefined();
|
||||
expect(optimization.beforeMetrics).toBeDefined();
|
||||
expect(optimization.afterMetrics).toBeDefined();
|
||||
|
||||
const utilization = optimizerSkill.getResourceUtilization();
|
||||
expect(utilization.pools.length).toBeGreaterThan(0);
|
||||
expect(utilization.overallStatus).toBeDefined();
|
||||
});
|
||||
|
||||
test('agent selection and scoring', async () => {
|
||||
const orchestrator = new OrchestratorAgent();
|
||||
await orchestrator.initialize();
|
||||
|
||||
const taskId = await orchestrator.createTaskPlan(
|
||||
'Complex task requiring multiple skills',
|
||||
{
|
||||
requiredSkills: ['code-analysis', 'security-analysis', 'documentation'],
|
||||
requiredTools: ['Read', 'Write', 'Bash'],
|
||||
priority: 2,
|
||||
}
|
||||
);
|
||||
|
||||
expect(taskId).toBeDefined();
|
||||
|
||||
const status = orchestrator.getSystemStatus();
|
||||
const agents = status.agents;
|
||||
|
||||
// Check that agents have required capabilities
|
||||
expect(agents.every((agent) => agent.skills)).toBe(true);
|
||||
expect(agents.every((agent) => agent.tools)).toBe(true);
|
||||
expect(agents.every((agent) => agent.performance)).toBe(true);
|
||||
});
|
||||
|
||||
test('workflow template execution', async () => {
|
||||
const orchestrator = new OrchestratorAgent();
|
||||
await orchestrator.initialize();
|
||||
|
||||
const orchestrationSkill = new OrchestrationManagementSkill(orchestrator);
|
||||
|
||||
// Test creating a custom workflow template
|
||||
const customTemplateId = orchestrationSkill.createWorkflowTemplate({
|
||||
name: 'Test Workflow',
|
||||
description: 'A test workflow for unit testing',
|
||||
steps: [
|
||||
{
|
||||
id: 'step1',
|
||||
name: 'Test Step 1',
|
||||
description: 'First test step',
|
||||
agentType: 'general-purpose',
|
||||
requiredSkills: ['testing'],
|
||||
dependencies: [],
|
||||
},
|
||||
],
|
||||
defaultAgents: ['general-purpose'],
|
||||
requiredSkills: ['testing'],
|
||||
estimatedDuration: 5000,
|
||||
});
|
||||
|
||||
expect(customTemplateId).toBeDefined();
|
||||
|
||||
const templates = orchestrationSkill.getWorkflowTemplates();
|
||||
const customTemplate = templates.find((t) => t.id === customTemplateId);
|
||||
expect(customTemplate).toBeDefined();
|
||||
expect(customTemplate?.name).toBe('Test Workflow');
|
||||
});
|
||||
|
||||
test('performance monitoring', async () => {
|
||||
const orchestrator = new OrchestratorAgent();
|
||||
await orchestrator.initialize();
|
||||
|
||||
const status = orchestrator.getSystemStatus();
|
||||
|
||||
// Check that metrics are being tracked
|
||||
expect(status.metrics).toBeDefined();
|
||||
expect(typeof status.metrics.cpuUsage).toBe('number');
|
||||
expect(typeof status.metrics.memoryUsage).toBe('number');
|
||||
expect(typeof status.metrics.activeConnections).toBe('number');
|
||||
expect(typeof status.metrics.queueSize).toBe('number');
|
||||
expect(typeof status.metrics.throughput).toBe('number');
|
||||
});
|
||||
|
||||
test('task dependency management', async () => {
|
||||
const orchestrator = new OrchestratorAgent();
|
||||
await orchestrator.initialize();
|
||||
|
||||
// Create tasks with dependencies
|
||||
const task1Id = await orchestrator.createTaskPlan('First task', {
|
||||
priority: 1,
|
||||
});
|
||||
|
||||
const task2Id = await orchestrator.createTaskPlan(
|
||||
'Second task dependent on first',
|
||||
{
|
||||
priority: 1,
|
||||
dependencies: [task1Id],
|
||||
}
|
||||
);
|
||||
|
||||
expect(task1Id).toBeDefined();
|
||||
expect(task2Id).toBeDefined();
|
||||
|
||||
const status = orchestrator.getSystemStatus();
|
||||
const task2 = status.queuedTasks.find((t) => t.id === task2Id);
|
||||
expect(task2?.dependencies).toContain(task1Id);
|
||||
});
|
||||
818
agents/orchestrator/index.ts
Normal file
818
agents/orchestrator/index.ts
Normal file
@@ -0,0 +1,818 @@
|
||||
/**
|
||||
* Orchestrator Agent
|
||||
* Advanced orchestration agent for managing subagents, commands, MCP servers, and skills
|
||||
*/
|
||||
|
||||
import DynamicDiscoverySystem from './dynamic-discovery';
|
||||
|
||||
export interface AgentCapability {
|
||||
name: string;
|
||||
skills: string[];
|
||||
tools: string[];
|
||||
status: 'active' | 'inactive' | 'busy';
|
||||
currentTask?: string;
|
||||
performance: {
|
||||
successRate: number;
|
||||
avgExecutionTime: number;
|
||||
lastUsed: Date;
|
||||
};
|
||||
}
|
||||
|
||||
export interface TaskPlan {
|
||||
id: string;
|
||||
description: string;
|
||||
priority: number;
|
||||
estimatedDuration: number;
|
||||
requiredSkills: string[];
|
||||
requiredTools: string[];
|
||||
dependencies: string[];
|
||||
status: 'pending' | 'in_progress' | 'completed' | 'failed';
|
||||
assignedAgents: string[];
|
||||
startTime?: Date;
|
||||
endTime?: Date;
|
||||
result?: unknown;
|
||||
}
|
||||
|
||||
export interface OrchestrationConfig {
|
||||
maxParallelAgents: number;
|
||||
taskTimeout: number;
|
||||
retryAttempts: number;
|
||||
skillMatchingThreshold: number;
|
||||
resourceAllocation: 'static' | 'dynamic';
|
||||
}
|
||||
|
||||
export interface ResourceMetrics {
|
||||
cpuUsage: number;
|
||||
memoryUsage: number;
|
||||
activeConnections: number;
|
||||
queueSize: number;
|
||||
throughput: number;
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
export class OrchestratorAgent {
|
||||
public readonly name = 'orchestrator';
|
||||
public readonly version = '1.0.0';
|
||||
|
||||
private agents: Map<string, AgentCapability> = new Map();
|
||||
private taskQueue: TaskPlan[] = [];
|
||||
private activeTasks: Map<string, TaskPlan> = new Map();
|
||||
private completedTasks: TaskPlan[] = [];
|
||||
private config: OrchestrationConfig;
|
||||
private metrics: ResourceMetrics;
|
||||
private discoverySystem: DynamicDiscoverySystem;
|
||||
private taskCounter = 1;
|
||||
|
||||
/**
|
||||
*
|
||||
* @param config
|
||||
*/
|
||||
constructor(config?: Partial<OrchestrationConfig>) {
|
||||
this.config = {
|
||||
maxParallelAgents: 10,
|
||||
taskTimeout: 300000,
|
||||
retryAttempts: 3,
|
||||
skillMatchingThreshold: 0.7,
|
||||
resourceAllocation: 'dynamic',
|
||||
...config,
|
||||
};
|
||||
|
||||
this.metrics = {
|
||||
cpuUsage: 0,
|
||||
memoryUsage: 0,
|
||||
activeConnections: 0,
|
||||
queueSize: 0,
|
||||
throughput: 0,
|
||||
};
|
||||
|
||||
this.discoverySystem = new DynamicDiscoverySystem();
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize the orchestrator and discover available agents
|
||||
*/
|
||||
async initialize(): Promise<void> {
|
||||
console.log(`Initializing ${this.name} v${this.version}`);
|
||||
await this.discoverAgents();
|
||||
await this.discoverSkills();
|
||||
await this.discoverCommands();
|
||||
await this.discoverMCPServers();
|
||||
console.log(`Discovered ${this.agents.size} agents`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Discover all available agents in the system (now dynamic!)
|
||||
*/
|
||||
private async discoverAgents(): Promise<void> {
|
||||
try {
|
||||
console.log('🔍 Discovering agents dynamically...');
|
||||
|
||||
// Use dynamic discovery system
|
||||
const discoveredAgents =
|
||||
await this.discoverySystem.getDiscoveryData('agents');
|
||||
|
||||
if (discoveredAgents.length > 0) {
|
||||
console.log(
|
||||
`✅ Discovered ${discoveredAgents.length} agents dynamically`
|
||||
);
|
||||
|
||||
for (const agent of discoveredAgents) {
|
||||
this.agents.set(agent.name, agent);
|
||||
}
|
||||
} else {
|
||||
console.log('⚠️ No dynamic agents found, using fallback static list');
|
||||
await this.discoverAgentsStatic();
|
||||
}
|
||||
} catch (error) {
|
||||
console.error(
|
||||
'❌ Error in dynamic agent discovery, using static fallback:',
|
||||
error
|
||||
);
|
||||
await this.discoverAgentsStatic();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Fallback static agent discovery
|
||||
*/
|
||||
private async discoverAgentsStatic(): Promise<void> {
|
||||
const agentTypes = [
|
||||
'general-purpose',
|
||||
'statusline-setup',
|
||||
'Explore',
|
||||
'Plan',
|
||||
'superpowers:code-reviewer',
|
||||
'episodic-memory:search-conversations',
|
||||
'agent-sdk-dev:agent-sdk-verifier-py',
|
||||
'agent-sdk-dev:agent-sdk-verifier-ts',
|
||||
'pr-review-toolkit:code-reviewer',
|
||||
'pr-review-toolkit:code-simplifier',
|
||||
'pr-review-toolkit:comment-analyzer',
|
||||
'pr-review-toolkit:pr-test-analyzer',
|
||||
'pr-review-toolkit:silent-failure-hunter',
|
||||
'pr-review-toolkit:type-design-analyzer',
|
||||
'feature-dev:code-architect',
|
||||
'feature-dev:code-explorer',
|
||||
'feature-dev:code-reviewer',
|
||||
'studio-cc:cc-expert-examples',
|
||||
'studio-cc:cc-expert',
|
||||
'astrojs-specialist',
|
||||
'agent-creator',
|
||||
'lint-typescript-fixer',
|
||||
];
|
||||
|
||||
for (const agentType of agentTypes) {
|
||||
this.agents.set(agentType, {
|
||||
name: agentType,
|
||||
skills: await this.getAgentSkills(agentType),
|
||||
tools: await this.getAgentTools(agentType),
|
||||
status: 'inactive',
|
||||
performance: {
|
||||
successRate: 1.0,
|
||||
avgExecutionTime: 0,
|
||||
lastUsed: new Date(),
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Discover available skills in the system (now dynamic!)
|
||||
*/
|
||||
private async discoverSkills(): Promise<string[]> {
|
||||
try {
|
||||
console.log('🔍 Discovering skills dynamically...');
|
||||
|
||||
// Use dynamic discovery system
|
||||
const discoveredSkills =
|
||||
await this.discoverySystem.getDiscoveryData('skills');
|
||||
|
||||
if (discoveredSkills.length > 0) {
|
||||
console.log(
|
||||
`✅ Discovered ${discoveredSkills.length} skills dynamically`
|
||||
);
|
||||
return discoveredSkills;
|
||||
}
|
||||
console.log('⚠️ No dynamic skills found, using fallback static list');
|
||||
return await this.discoverSkillsStatic();
|
||||
|
||||
} catch (error) {
|
||||
console.error(
|
||||
'❌ Error in dynamic skill discovery, using static fallback:',
|
||||
error
|
||||
);
|
||||
return await this.discoverSkillsStatic();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Fallback static skill discovery
|
||||
*/
|
||||
private async discoverSkillsStatic(): Promise<string[]> {
|
||||
return [
|
||||
'n8n-code-javascript',
|
||||
'n8n-code-python',
|
||||
'n8n-expression-syntax',
|
||||
'n8n-mcp-tools-expert',
|
||||
'n8n-node-configuration',
|
||||
'n8n-validation-expert',
|
||||
'n8n-workflow-patterns',
|
||||
'superpowers:brainstorming',
|
||||
'superpowers:condition-based-waiting',
|
||||
'superpowers:defense-in-depth',
|
||||
'superpowers:dispatching-parallel-agents',
|
||||
'superpowers:executing-plans',
|
||||
'superpowers:finishing-a-development-branch',
|
||||
'superpowers:receiving-code-review',
|
||||
'superpowers:requesting-code-review',
|
||||
'superpowers:root-cause-tracing',
|
||||
'superpowers:sharing-skills',
|
||||
'superpowers:subagent-driven-development',
|
||||
'superpowers:systematic-debugging',
|
||||
'superpowers:test-driven-development',
|
||||
'superpowers:testing-anti-patterns',
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Discover available commands in the system (now dynamic!)
|
||||
*/
|
||||
private async discoverCommands(): Promise<string[]> {
|
||||
try {
|
||||
console.log('🔍 Discovering commands dynamically...');
|
||||
|
||||
// Use dynamic discovery system
|
||||
const discoveredCommands =
|
||||
await this.discoverySystem.getDiscoveryData('commands');
|
||||
|
||||
if (discoveredCommands.length > 0) {
|
||||
console.log(
|
||||
`✅ Discovered ${discoveredCommands.length} commands dynamically`
|
||||
);
|
||||
return discoveredCommands;
|
||||
}
|
||||
console.log('⚠️ No dynamic commands found, using fallback static list');
|
||||
return await this.discoverCommandsStatic();
|
||||
|
||||
} catch (error) {
|
||||
console.error(
|
||||
'❌ Error in dynamic command discovery, using static fallback:',
|
||||
error
|
||||
);
|
||||
return await this.discoverCommandsStatic();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Fallback static command discovery
|
||||
*/
|
||||
private async discoverCommandsStatic(): Promise<string[]> {
|
||||
return [
|
||||
'/superpowers:brainstorm',
|
||||
'/superpowers:execute-plan',
|
||||
'/superpowers:write-plan',
|
||||
'/episodic-memory:search-conversations',
|
||||
'/agent-sdk-dev:new-sdk-app',
|
||||
'/pr-review-toolkit:review-pr',
|
||||
'/commit-commands:clean_gone',
|
||||
'/commit-commands:commit-push-pr',
|
||||
'/commit-commands:commit',
|
||||
'/feature-dev:feature-dev',
|
||||
'/code-review:code-review',
|
||||
'/studio-cc:cc-plugin',
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Discover available MCP servers (now dynamic!)
|
||||
*/
|
||||
private async discoverMCPServers(): Promise<string[]> {
|
||||
try {
|
||||
console.log('🔍 Discovering MCP servers dynamically...');
|
||||
|
||||
// Use dynamic discovery system
|
||||
const discoveredMCPServers =
|
||||
await this.discoverySystem.getDiscoveryData('mcp');
|
||||
|
||||
if (discoveredMCPServers.length > 0) {
|
||||
console.log(
|
||||
`✅ Discovered ${discoveredMCPServers.length} MCP servers dynamically`
|
||||
);
|
||||
return discoveredMCPServers;
|
||||
}
|
||||
console.log(
|
||||
'⚠️ No dynamic MCP servers found, using fallback static list'
|
||||
);
|
||||
return await this.discoverMCPServersStatic();
|
||||
|
||||
} catch (error) {
|
||||
console.error(
|
||||
'❌ Error in dynamic MCP server discovery, using static fallback:',
|
||||
error
|
||||
);
|
||||
return await this.discoverMCPServersStatic();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Fallback static MCP server discovery
|
||||
*/
|
||||
private async discoverMCPServersStatic(): Promise<string[]> {
|
||||
return ['superpowers-chrome', 'web-search-prime', 'zai-mcp-server'];
|
||||
}
|
||||
|
||||
/**
|
||||
* Force refresh all discovery data
|
||||
*/
|
||||
async refreshDiscoveryData(): Promise<void> {
|
||||
console.log('🔄 Force refreshing all discovery data...');
|
||||
await this.discoverySystem.refreshAll();
|
||||
console.log('✅ Discovery data refreshed');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get discovery system status
|
||||
*/
|
||||
getDiscoveryStatus(): {
|
||||
sources: Array<{
|
||||
name: string;
|
||||
type: string;
|
||||
lastUpdate: Date;
|
||||
status: 'updated' | 'stale' | 'error';
|
||||
}>;
|
||||
cacheSize: number;
|
||||
} {
|
||||
return this.discoverySystem.getDiscoveryStatus();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get skills for a specific agent
|
||||
* @param agentType
|
||||
*/
|
||||
private async getAgentSkills(agentType: string): Promise<string[]> {
|
||||
const skillMap: Record<string, string[]> = {
|
||||
'general-purpose': ['web-search', 'code-analysis'],
|
||||
'feature-dev:code-architect': ['architecture', 'design-patterns'],
|
||||
'pr-review-toolkit:code-reviewer': ['code-review', 'quality-analysis'],
|
||||
'superpowers:code-reviewer': ['security-analysis', 'performance-review'],
|
||||
'agent-creator': ['template-generation', 'skill-development'],
|
||||
};
|
||||
return skillMap[agentType] || [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Get tools for a specific agent
|
||||
* @param agentType
|
||||
*/
|
||||
private async getAgentTools(agentType: string): Promise<string[]> {
|
||||
const toolMap: Record<string, string[]> = {
|
||||
'general-purpose': ['Read', 'Write', 'Edit', 'Bash', 'WebFetch'],
|
||||
'feature-dev:code-architect': ['Glob', 'Grep', 'TodoWrite'],
|
||||
'pr-review-toolkit:code-reviewer': ['Read', 'Grep', 'Bash'],
|
||||
'superpowers:code-reviewer': ['Task', 'Read', 'Grep'],
|
||||
'agent-creator': ['Write', 'WebFetch', 'MultiEdit'],
|
||||
};
|
||||
return toolMap[agentType] || ['Read', 'Write'];
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a task plan and orchestrate execution
|
||||
* @param description
|
||||
* @param requirements
|
||||
* @param requirements.priority
|
||||
* @param requirements.requiredSkills
|
||||
* @param requirements.requiredTools
|
||||
* @param requirements.dependencies
|
||||
*/
|
||||
async createTaskPlan(
|
||||
description: string,
|
||||
requirements?: {
|
||||
priority?: number;
|
||||
requiredSkills?: string[];
|
||||
requiredTools?: string[];
|
||||
dependencies?: string[];
|
||||
}
|
||||
): Promise<string> {
|
||||
const taskPlan: TaskPlan = {
|
||||
id: `task_${Date.now()}_${this.taskCounter++}`,
|
||||
description,
|
||||
priority: requirements?.priority || 1,
|
||||
estimatedDuration: this.estimateTaskDuration(description, requirements),
|
||||
requiredSkills: requirements?.requiredSkills || [],
|
||||
requiredTools: requirements?.requiredTools || [],
|
||||
dependencies: requirements?.dependencies || [],
|
||||
status: 'pending',
|
||||
assignedAgents: [],
|
||||
};
|
||||
|
||||
this.taskQueue.push(taskPlan);
|
||||
this.metrics.queueSize = this.taskQueue.length;
|
||||
|
||||
// Auto-execute if no dependencies
|
||||
if (taskPlan.dependencies.length === 0) {
|
||||
await this.executeTask(taskPlan.id);
|
||||
}
|
||||
|
||||
return taskPlan.id;
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute a task plan with optimal agent allocation
|
||||
* @param taskId
|
||||
*/
|
||||
async executeTask(taskId: string): Promise<void> {
|
||||
const task =
|
||||
this.taskQueue.find((t) => t.id === taskId) ||
|
||||
this.activeTasks.get(taskId);
|
||||
|
||||
if (!task) {
|
||||
throw new Error(`Task ${taskId} not found`);
|
||||
}
|
||||
|
||||
task.status = 'in_progress';
|
||||
task.startTime = new Date();
|
||||
this.activeTasks.set(taskId, task);
|
||||
|
||||
// Remove from queue if it was there
|
||||
const queueIndex = this.taskQueue.findIndex((t) => t.id === taskId);
|
||||
if (queueIndex >= 0) {
|
||||
this.taskQueue.splice(queueIndex, 1);
|
||||
}
|
||||
|
||||
try {
|
||||
// Find best agents for the task
|
||||
const selectedAgents = await this.selectOptimalAgents(task);
|
||||
task.assignedAgents = selectedAgents;
|
||||
|
||||
// Execute agents in parallel where possible
|
||||
const results = await this.executeAgentsInParallel(selectedAgents, task);
|
||||
|
||||
// Process results and complete task
|
||||
task.result = results;
|
||||
task.status = 'completed';
|
||||
task.endTime = new Date();
|
||||
|
||||
// Move to completed tasks
|
||||
this.completedTasks.push(task);
|
||||
this.activeTasks.delete(taskId);
|
||||
|
||||
// Check for dependent tasks
|
||||
await this.checkDependentTasks(taskId);
|
||||
|
||||
console.log(`Task ${taskId} completed successfully`);
|
||||
} catch (error) {
|
||||
task.status = 'failed';
|
||||
task.endTime = new Date();
|
||||
task.result = { error: error.message };
|
||||
|
||||
console.error(`Task ${taskId} failed:`, error);
|
||||
|
||||
// Retry logic
|
||||
if (this.shouldRetry(task)) {
|
||||
await this.retryTask(taskId);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Select optimal agents for a given task
|
||||
* @param _task
|
||||
*/
|
||||
private async selectOptimalAgents(_task: TaskPlan): Promise<string[]> {
|
||||
const availableAgents = Array.from(this.agents.entries())
|
||||
.filter(([, agent]) => agent.status === 'inactive')
|
||||
.map(([name, agent]) => ({ name, agent }));
|
||||
|
||||
// Score agents based on skill and tool matching
|
||||
const scoredAgents = availableAgents.map(({ name, agent }) => {
|
||||
const skillScore = this.calculateSkillMatch(
|
||||
agent.skills,
|
||||
_task.requiredSkills
|
||||
);
|
||||
const toolScore = this.calculateToolMatch(
|
||||
agent.tools,
|
||||
_task.requiredTools
|
||||
);
|
||||
const performanceScore = agent.performance.successRate;
|
||||
|
||||
const totalScore =
|
||||
skillScore * 0.4 + toolScore * 0.3 + performanceScore * 0.3;
|
||||
|
||||
return { name, score: totalScore };
|
||||
});
|
||||
|
||||
// Sort by score and select top agents
|
||||
scoredAgents.sort((a, b) => b.score - a.score);
|
||||
|
||||
// Select agents that meet the threshold
|
||||
const selectedAgents = scoredAgents
|
||||
.filter((agent) => agent.score >= this.config.skillMatchingThreshold)
|
||||
.slice(0, this.config.maxParallelAgents)
|
||||
.map((agent) => agent.name);
|
||||
|
||||
// Mark selected agents as busy
|
||||
for (const agentName of selectedAgents) {
|
||||
const agent = this.agents.get(agentName);
|
||||
if (agent) {
|
||||
agent.status = 'busy';
|
||||
agent.currentTask = _task.id;
|
||||
}
|
||||
}
|
||||
|
||||
return selectedAgents;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate skill match score
|
||||
* @param agentSkills
|
||||
* @param requiredSkills
|
||||
*/
|
||||
private calculateSkillMatch(
|
||||
agentSkills: string[],
|
||||
requiredSkills: string[]
|
||||
): number {
|
||||
if (requiredSkills.length === 0) return 1.0;
|
||||
|
||||
const matchingSkills = agentSkills.filter((skill) =>
|
||||
requiredSkills.some(
|
||||
(required) =>
|
||||
skill.toLowerCase().includes(required.toLowerCase()) ||
|
||||
required.toLowerCase().includes(skill.toLowerCase())
|
||||
)
|
||||
);
|
||||
|
||||
return matchingSkills.length / requiredSkills.length;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate tool match score
|
||||
* @param agentTools
|
||||
* @param requiredTools
|
||||
*/
|
||||
private calculateToolMatch(
|
||||
agentTools: string[],
|
||||
requiredTools: string[]
|
||||
): number {
|
||||
if (requiredTools.length === 0) return 1.0;
|
||||
|
||||
const matchingTools = agentTools.filter((tool) =>
|
||||
requiredTools.includes(tool)
|
||||
);
|
||||
return matchingTools.length / requiredTools.length;
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute multiple agents in parallel
|
||||
* @param agentNames
|
||||
* @param task
|
||||
*/
|
||||
private async executeAgentsInParallel(
|
||||
agentNames: string[],
|
||||
task: TaskPlan
|
||||
): Promise<any[]> {
|
||||
// Create parallel execution tasks
|
||||
const agentTasks = agentNames.map(async (agentName) => {
|
||||
const agent = this.agents.get(agentName);
|
||||
if (!agent) throw new Error(`Agent ${agentName} not found`);
|
||||
|
||||
const startTime = Date.now();
|
||||
|
||||
try {
|
||||
// Execute the agent task
|
||||
const result = await this.executeAgentTask(agentName, task);
|
||||
|
||||
// Update agent performance
|
||||
const executionTime = Date.now() - startTime;
|
||||
this.updateAgentPerformance(agentName, true, executionTime);
|
||||
|
||||
return { agent: agentName, result, success: true };
|
||||
} catch (error) {
|
||||
// Update agent performance
|
||||
const executionTime = Date.now() - startTime;
|
||||
this.updateAgentPerformance(agentName, false, executionTime);
|
||||
|
||||
return { agent: agentName, error: error.message, success: false };
|
||||
}
|
||||
});
|
||||
|
||||
// Wait for all agents to complete
|
||||
const results = await Promise.all(agentTasks);
|
||||
|
||||
// Release agents
|
||||
for (const agentName of agentNames) {
|
||||
const agent = this.agents.get(agentName);
|
||||
if (agent) {
|
||||
agent.status = 'inactive';
|
||||
agent.currentTask = undefined;
|
||||
}
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute a specific agent task
|
||||
* @param agentName
|
||||
* @param task
|
||||
*/
|
||||
private async executeAgentTask(
|
||||
agentName: string,
|
||||
task: TaskPlan
|
||||
): Promise<any> {
|
||||
// This would integrate with the actual agent execution system
|
||||
console.log(`Executing agent ${agentName} for task ${task.id}`);
|
||||
|
||||
// Simulate agent execution
|
||||
await new Promise((resolve) => setTimeout(resolve, 1000));
|
||||
|
||||
return {
|
||||
agent: agentName,
|
||||
taskId: task.id,
|
||||
output: `Task processed by ${agentName}`,
|
||||
timestamp: new Date(),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Update agent performance metrics
|
||||
* @param agentName
|
||||
* @param success
|
||||
* @param executionTime
|
||||
*/
|
||||
private updateAgentPerformance(
|
||||
agentName: string,
|
||||
success: boolean,
|
||||
executionTime: number
|
||||
): void {
|
||||
const agent = this.agents.get(agentName);
|
||||
if (!agent) return;
|
||||
|
||||
// Update success rate (exponential moving average)
|
||||
const alpha = 0.1;
|
||||
agent.performance.successRate =
|
||||
alpha * (success ? 1 : 0) + (1 - alpha) * agent.performance.successRate;
|
||||
|
||||
// Update average execution time
|
||||
agent.performance.avgExecutionTime =
|
||||
alpha * executionTime + (1 - alpha) * agent.performance.avgExecutionTime;
|
||||
|
||||
agent.performance.lastUsed = new Date();
|
||||
}
|
||||
|
||||
/**
|
||||
* Estimate task duration based on complexity
|
||||
* @param description
|
||||
* @param requirements
|
||||
*/
|
||||
private estimateTaskDuration(
|
||||
description: string,
|
||||
requirements?: Record<string, unknown>
|
||||
): number {
|
||||
// Simple heuristic based on description length and complexity
|
||||
const baseTime = 5000; // 5 seconds base
|
||||
const complexityMultiplier = Math.max(1, description.length / 100);
|
||||
const skillMultiplier = Math.max(
|
||||
1,
|
||||
(requirements?.requiredSkills?.length || 0) / 2
|
||||
);
|
||||
|
||||
return Math.floor(baseTime * complexityMultiplier * skillMultiplier);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if task should be retried
|
||||
* @param _task
|
||||
*/
|
||||
private shouldRetry(_task: TaskPlan): boolean {
|
||||
// This would track retry attempts
|
||||
return true; // Simplified for now
|
||||
}
|
||||
|
||||
/**
|
||||
* Retry a failed task
|
||||
* @param taskId
|
||||
*/
|
||||
private async retryTask(taskId: string): Promise<void> {
|
||||
const task = this.activeTasks.get(taskId);
|
||||
if (!task) return;
|
||||
|
||||
task.status = 'pending';
|
||||
this.activeTasks.delete(taskId);
|
||||
this.taskQueue.push(task);
|
||||
|
||||
await this.executeTask(taskId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check for tasks that depend on completed task
|
||||
* @param completedTaskId
|
||||
*/
|
||||
private async checkDependentTasks(completedTaskId: string): Promise<void> {
|
||||
const dependentTasks = this.taskQueue.filter((task) =>
|
||||
task.dependencies.includes(completedTaskId)
|
||||
);
|
||||
|
||||
for (const task of dependentTasks) {
|
||||
// Check if all dependencies are completed
|
||||
const allDependenciesMet = task.dependencies.every((depId) =>
|
||||
this.completedTasks.some((completed) => completed.id === depId)
|
||||
);
|
||||
|
||||
if (allDependenciesMet) {
|
||||
await this.executeTask(task.id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get system status and metrics
|
||||
*/
|
||||
getSystemStatus(): {
|
||||
agents: AgentCapability[];
|
||||
activeTasks: TaskPlan[];
|
||||
queuedTasks: TaskPlan[];
|
||||
completedTasks: TaskPlan[];
|
||||
metrics: ResourceMetrics;
|
||||
} {
|
||||
return {
|
||||
agents: Array.from(this.agents.values()),
|
||||
activeTasks: Array.from(this.activeTasks.values()),
|
||||
queuedTasks: this.taskQueue,
|
||||
completedTasks: this.completedTasks,
|
||||
metrics: this.metrics,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Get available skills across all agents
|
||||
*/
|
||||
getAvailableSkills(): string[] {
|
||||
const allSkills = new Set<string>();
|
||||
for (const [, agent] of this.agents) {
|
||||
for (const skill of agent.skills) allSkills.add(skill);
|
||||
}
|
||||
return Array.from(allSkills);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get available commands
|
||||
*/
|
||||
async getAvailableCommands(): Promise<string[]> {
|
||||
return await this.discoverCommands();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get available MCP servers
|
||||
*/
|
||||
async getAvailableMCPServers(): Promise<string[]> {
|
||||
return await this.discoverMCPServers();
|
||||
}
|
||||
|
||||
/**
|
||||
* Allocate skills to tasks based on requirements
|
||||
* @param taskId
|
||||
* @param requiredSkills
|
||||
*/
|
||||
allocateSkillsToTask(taskId: string, requiredSkills: string[]): string[] {
|
||||
const task =
|
||||
this.activeTasks.get(taskId) ||
|
||||
this.taskQueue.find((t) => t.id === taskId) ||
|
||||
this.completedTasks.find((t) => t.id === taskId);
|
||||
|
||||
if (!task) return [];
|
||||
|
||||
const availableSkills = this.getAvailableSkills();
|
||||
const allocatedSkills = requiredSkills.filter((skill) =>
|
||||
availableSkills.includes(skill)
|
||||
);
|
||||
|
||||
task.requiredSkills = allocatedSkills;
|
||||
return allocatedSkills;
|
||||
}
|
||||
|
||||
/**
|
||||
* Shutdown the orchestrator
|
||||
*/
|
||||
async shutdown(): Promise<void> {
|
||||
console.log('Shutting down orchestrator...');
|
||||
|
||||
// Wait for active tasks to complete or timeout
|
||||
const maxWaitTime = 30000; // 30 seconds
|
||||
const startTime = Date.now();
|
||||
|
||||
while (this.activeTasks.size > 0 && Date.now() - startTime < maxWaitTime) {
|
||||
await new Promise((resolve) => setTimeout(resolve, 1000));
|
||||
}
|
||||
|
||||
// Cleanup discovery system
|
||||
if (this.discoverySystem) {
|
||||
this.discoverySystem.destroy();
|
||||
}
|
||||
|
||||
console.log('Orchestrator shutdown complete');
|
||||
}
|
||||
}
|
||||
|
||||
export default OrchestratorAgent;
|
||||
35
agents/orchestrator/package.json
Normal file
35
agents/orchestrator/package.json
Normal file
@@ -0,0 +1,35 @@
|
||||
{
|
||||
"name": "orchestrator-agent",
|
||||
"description": "Advanced orchestration agent for managing subagents, commands, MCP servers, and skills",
|
||||
"version": "1.0.0",
|
||||
"main": "index.ts",
|
||||
"type": "module",
|
||||
"skills": [
|
||||
"./skills/orchestration-management",
|
||||
"./skills/resource-optimizer"
|
||||
],
|
||||
"dependencies": {
|
||||
"zod": "^4.1.12"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/node": "^24.10.0",
|
||||
"eslint": "^9.39.0",
|
||||
"prettier": "^3.0.0",
|
||||
"typescript": "^5.0.0"
|
||||
},
|
||||
"scripts": {
|
||||
"build": "bun build --target esm",
|
||||
"test": "bun test",
|
||||
"lint": "../../../agents/orchestrator/node_modules/.bin/eslint --fix",
|
||||
"format": "../../../agents/orchestrator/node_modules/.bin/prettier --write ",
|
||||
"type-check": "../../../agents/orchestrator/node_modules/.bin/tsc --noEmit"
|
||||
},
|
||||
"keywords": [
|
||||
"agent",
|
||||
"orchestration",
|
||||
"claude-code",
|
||||
"automation"
|
||||
],
|
||||
"author": "Eduardo Menoncello",
|
||||
"license": "MIT"
|
||||
}
|
||||
462
agents/orchestrator/skills/orchestration-management.ts
Normal file
462
agents/orchestrator/skills/orchestration-management.ts
Normal file
@@ -0,0 +1,462 @@
|
||||
/**
|
||||
* Orchestration Management Skill
|
||||
* Advanced skill for managing complex orchestration scenarios
|
||||
*/
|
||||
|
||||
import { OrchestratorAgent } from '../index';
|
||||
|
||||
export interface OrchestrationStrategy {
|
||||
name: string;
|
||||
description: string;
|
||||
parallelExecution: boolean;
|
||||
resourceAllocation: 'aggressive' | 'conservative' | 'balanced';
|
||||
priorityWeighting: number;
|
||||
}
|
||||
|
||||
export interface WorkflowTemplate {
|
||||
id: string;
|
||||
name: string;
|
||||
description: string;
|
||||
steps: WorkflowStep[];
|
||||
defaultAgents: string[];
|
||||
requiredSkills: string[];
|
||||
estimatedDuration: number;
|
||||
}
|
||||
|
||||
export interface WorkflowStep {
|
||||
id: string;
|
||||
name: string;
|
||||
description: string;
|
||||
agentType: string;
|
||||
requiredSkills: string[];
|
||||
dependencies: string[];
|
||||
parallelGroup?: string;
|
||||
timeout?: number;
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
export class OrchestrationManagementSkill {
|
||||
private orchestrator: OrchestratorAgent;
|
||||
private workflowTemplates: Map<string, WorkflowTemplate> = new Map();
|
||||
private strategies: Map<string, OrchestrationStrategy> = new Map();
|
||||
private workflowCounter = 1;
|
||||
|
||||
/**
|
||||
*
|
||||
* @param orchestrator
|
||||
*/
|
||||
constructor(orchestrator: OrchestratorAgent) {
|
||||
this.orchestrator = orchestrator;
|
||||
this.initializeStrategies();
|
||||
this.initializeWorkflowTemplates();
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize orchestration strategies
|
||||
*/
|
||||
private initializeStrategies(): void {
|
||||
const strategies: OrchestrationStrategy[] = [
|
||||
{
|
||||
name: 'performance',
|
||||
description: 'Optimize for maximum performance and speed',
|
||||
parallelExecution: true,
|
||||
resourceAllocation: 'aggressive',
|
||||
priorityWeighting: 0.8,
|
||||
},
|
||||
{
|
||||
name: 'balanced',
|
||||
description: 'Balance between performance and resource usage',
|
||||
parallelExecution: true,
|
||||
resourceAllocation: 'balanced',
|
||||
priorityWeighting: 0.5,
|
||||
},
|
||||
{
|
||||
name: 'conservative',
|
||||
description: 'Prioritize stability and resource efficiency',
|
||||
parallelExecution: false,
|
||||
resourceAllocation: 'conservative',
|
||||
priorityWeighting: 0.3,
|
||||
},
|
||||
{
|
||||
name: 'development',
|
||||
description: 'Optimized for development workflows',
|
||||
parallelExecution: true,
|
||||
resourceAllocation: 'balanced',
|
||||
priorityWeighting: 0.6,
|
||||
},
|
||||
{
|
||||
name: 'testing',
|
||||
description: 'Optimized for testing and validation workflows',
|
||||
parallelExecution: true,
|
||||
resourceAllocation: 'conservative',
|
||||
priorityWeighting: 0.7,
|
||||
},
|
||||
];
|
||||
|
||||
for (const strategy of strategies) {
|
||||
this.strategies.set(strategy.name, strategy);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize workflow templates
|
||||
*/
|
||||
private initializeWorkflowTemplates(): void {
|
||||
const templates: WorkflowTemplate[] = [
|
||||
{
|
||||
id: 'code-review-workflow',
|
||||
name: 'Complete Code Review Workflow',
|
||||
description: 'End-to-end code review with multiple analysis stages',
|
||||
steps: [
|
||||
{
|
||||
id: 'static-analysis',
|
||||
name: 'Static Code Analysis',
|
||||
description: 'Perform static analysis on code changes',
|
||||
agentType: 'pr-review-toolkit:code-reviewer',
|
||||
requiredSkills: ['code-review', 'static-analysis'],
|
||||
dependencies: [],
|
||||
},
|
||||
{
|
||||
id: 'security-analysis',
|
||||
name: 'Security Analysis',
|
||||
description: 'Analyze security vulnerabilities',
|
||||
agentType: 'superpowers:code-reviewer',
|
||||
requiredSkills: ['security-analysis', 'vulnerability-assessment'],
|
||||
dependencies: [],
|
||||
parallelGroup: 'analysis-phase',
|
||||
},
|
||||
{
|
||||
id: 'performance-analysis',
|
||||
name: 'Performance Analysis',
|
||||
description: 'Analyze performance implications',
|
||||
agentType: 'feature-dev:code-reviewer',
|
||||
requiredSkills: ['performance-analysis', 'optimization'],
|
||||
dependencies: [],
|
||||
parallelGroup: 'analysis-phase',
|
||||
},
|
||||
{
|
||||
id: 'documentation-review',
|
||||
name: 'Documentation Review',
|
||||
description: 'Review documentation completeness',
|
||||
agentType: 'pr-review-toolkit:comment-analyzer',
|
||||
requiredSkills: ['documentation', 'technical-writing'],
|
||||
dependencies: ['static-analysis'],
|
||||
},
|
||||
],
|
||||
defaultAgents: [
|
||||
'pr-review-toolkit:code-reviewer',
|
||||
'superpowers:code-reviewer',
|
||||
'feature-dev:code-reviewer',
|
||||
'pr-review-toolkit:comment-analyzer',
|
||||
],
|
||||
requiredSkills: [
|
||||
'code-review',
|
||||
'security-analysis',
|
||||
'performance-analysis',
|
||||
'documentation',
|
||||
],
|
||||
estimatedDuration: 15000,
|
||||
},
|
||||
{
|
||||
id: 'feature-development-workflow',
|
||||
name: 'Feature Development Workflow',
|
||||
description: 'Complete feature development from planning to deployment',
|
||||
steps: [
|
||||
{
|
||||
id: 'requirements-analysis',
|
||||
name: 'Requirements Analysis',
|
||||
description: 'Analyze and clarify requirements',
|
||||
agentType: 'feature-dev:code-architect',
|
||||
requiredSkills: ['requirements-analysis', 'architecture'],
|
||||
dependencies: [],
|
||||
},
|
||||
{
|
||||
id: 'design-planning',
|
||||
name: 'Design and Planning',
|
||||
description: 'Create detailed design and implementation plan',
|
||||
agentType: 'feature-dev:code-architect',
|
||||
requiredSkills: ['design-patterns', 'planning'],
|
||||
dependencies: ['requirements-analysis'],
|
||||
},
|
||||
{
|
||||
id: 'implementation',
|
||||
name: 'Implementation',
|
||||
description: 'Implement the feature',
|
||||
agentType: 'general-purpose',
|
||||
requiredSkills: ['coding', 'implementation'],
|
||||
dependencies: ['design-planning'],
|
||||
},
|
||||
{
|
||||
id: 'testing',
|
||||
name: 'Testing',
|
||||
description: 'Create and run tests',
|
||||
agentType: 'general-purpose',
|
||||
requiredSkills: ['testing', 'quality-assurance'],
|
||||
dependencies: ['implementation'],
|
||||
},
|
||||
{
|
||||
id: 'documentation',
|
||||
name: 'Documentation',
|
||||
description: 'Create documentation',
|
||||
agentType: 'pr-review-toolkit:comment-analyzer',
|
||||
requiredSkills: ['documentation', 'technical-writing'],
|
||||
dependencies: ['implementation'],
|
||||
},
|
||||
],
|
||||
defaultAgents: [
|
||||
'feature-dev:code-architect',
|
||||
'general-purpose',
|
||||
'pr-review-toolkit:comment-analyzer',
|
||||
],
|
||||
requiredSkills: [
|
||||
'requirements-analysis',
|
||||
'architecture',
|
||||
'design-patterns',
|
||||
'coding',
|
||||
'testing',
|
||||
'documentation',
|
||||
],
|
||||
estimatedDuration: 60000,
|
||||
},
|
||||
];
|
||||
|
||||
for (const template of templates) {
|
||||
this.workflowTemplates.set(template.id, template);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute a workflow template
|
||||
* @param templateId
|
||||
* @param customizations
|
||||
* @param customizations.parameters
|
||||
* @param customizations.agentOverrides
|
||||
* @param customizations.skillOverrides
|
||||
*/
|
||||
async executeWorkflow(
|
||||
templateId: string,
|
||||
customizations?: {
|
||||
parameters?: Record<string, unknown>;
|
||||
agentOverrides?: Record<string, string>;
|
||||
skillOverrides?: Record<string, string[]>;
|
||||
}
|
||||
): Promise<string> {
|
||||
const template = this.workflowTemplates.get(templateId);
|
||||
if (!template) {
|
||||
throw new Error(`Workflow template ${templateId} not found`);
|
||||
}
|
||||
|
||||
console.log(`Executing workflow: ${template.name}`);
|
||||
|
||||
// Create main task plan for the workflow
|
||||
const workflowTaskId = await this.orchestrator.createTaskPlan(
|
||||
`Execute workflow: ${template.name}`,
|
||||
{
|
||||
priority: 1,
|
||||
requiredSkills: template.requiredSkills,
|
||||
estimatedDuration: template.estimatedDuration,
|
||||
}
|
||||
);
|
||||
|
||||
// Create task plans for each step
|
||||
const stepTasks: string[] = [];
|
||||
const parallelGroups: Map<string, string[]> = new Map();
|
||||
|
||||
for (const step of template.steps) {
|
||||
// Apply customizations
|
||||
const _agentType =
|
||||
customizations?.agentOverrides?.[step.id] || step.agentType;
|
||||
const requiredSkills =
|
||||
customizations?.skillOverrides?.[step.id] || step.requiredSkills;
|
||||
|
||||
const stepTaskId = await this.orchestrator.createTaskPlan(
|
||||
`Workflow step: ${step.name}`,
|
||||
{
|
||||
priority: 1,
|
||||
requiredSkills,
|
||||
dependencies: step.dependencies.map((depId) => {
|
||||
const depStep = template.steps.find((s) => s.id === depId);
|
||||
return depStep ? `${workflowTaskId}_${depId}` : depId;
|
||||
}),
|
||||
}
|
||||
);
|
||||
|
||||
stepTasks.push(stepTaskId);
|
||||
|
||||
// Track parallel groups
|
||||
if (step.parallelGroup) {
|
||||
if (!parallelGroups.has(step.parallelGroup)) {
|
||||
parallelGroups.set(step.parallelGroup, []);
|
||||
}
|
||||
const groupTasks = parallelGroups.get(step.parallelGroup);
|
||||
if (groupTasks) {
|
||||
groupTasks.push(stepTaskId);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Execute parallel groups
|
||||
for (const [, taskIds] of parallelGroups) {
|
||||
await this.executeParallelTasks(taskIds);
|
||||
}
|
||||
|
||||
// Execute remaining tasks sequentially
|
||||
const sequentialTasks = stepTasks.filter(
|
||||
(taskId) =>
|
||||
!Array.from(parallelGroups.values()).some((group) =>
|
||||
group.includes(taskId)
|
||||
)
|
||||
);
|
||||
|
||||
for (const taskId of sequentialTasks) {
|
||||
await this.orchestrator.executeTask(taskId);
|
||||
}
|
||||
|
||||
return workflowTaskId;
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute multiple tasks in parallel
|
||||
* @param taskIds
|
||||
*/
|
||||
private async executeParallelTasks(taskIds: string[]): Promise<void> {
|
||||
const promises = taskIds.map((taskId) =>
|
||||
this.orchestrator.executeTask(taskId)
|
||||
);
|
||||
await Promise.all(promises);
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply orchestration strategy to task execution
|
||||
* @param strategyName
|
||||
* @param taskIds
|
||||
*/
|
||||
async applyStrategy(strategyName: string, taskIds: string[]): Promise<void> {
|
||||
const strategy = this.strategies.get(strategyName);
|
||||
if (!strategy) {
|
||||
throw new Error(`Strategy ${strategyName} not found`);
|
||||
}
|
||||
|
||||
console.log(`Applying strategy: ${strategy.name}`);
|
||||
|
||||
if (strategy.parallelExecution) {
|
||||
await this.executeParallelTasks(taskIds);
|
||||
} else {
|
||||
for (const taskId of taskIds) {
|
||||
await this.orchestrator.executeTask(taskId);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Create custom workflow template
|
||||
* @param template
|
||||
*/
|
||||
createWorkflowTemplate(template: Omit<WorkflowTemplate, 'id'>): string {
|
||||
const id = `workflow_${Date.now()}_${this.workflowCounter++}`;
|
||||
const fullTemplate: WorkflowTemplate = { ...template, id };
|
||||
|
||||
this.workflowTemplates.set(id, fullTemplate);
|
||||
return id;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get available workflow templates
|
||||
*/
|
||||
getWorkflowTemplates(): WorkflowTemplate[] {
|
||||
return Array.from(this.workflowTemplates.values());
|
||||
}
|
||||
|
||||
/**
|
||||
* Get available strategies
|
||||
*/
|
||||
getStrategies(): OrchestrationStrategy[] {
|
||||
return Array.from(this.strategies.values());
|
||||
}
|
||||
|
||||
/**
|
||||
* Optimize task allocation based on system performance
|
||||
*/
|
||||
async optimizeTaskAllocation(): Promise<void> {
|
||||
const systemStatus = this.orchestrator.getSystemStatus();
|
||||
|
||||
// Analyze agent performance
|
||||
const agentPerformance = systemStatus.agents.map((agent) => ({
|
||||
name: agent.name,
|
||||
efficiency: agent.performance.successRate,
|
||||
avgTime: agent.performance.avgExecutionTime,
|
||||
utilization: agent.status === 'busy' ? 1 : 0,
|
||||
}));
|
||||
|
||||
// Sort by efficiency (success rate / execution time)
|
||||
agentPerformance.sort(
|
||||
(a, b) => b.efficiency / b.avgTime - a.efficiency / a.avgTime
|
||||
);
|
||||
|
||||
// Recommend optimal agents for different task types
|
||||
const recommendations = {
|
||||
'high-priority': agentPerformance.slice(0, 3).map((a) => a.name),
|
||||
'standard-priority': agentPerformance.slice(3, 6).map((a) => a.name),
|
||||
'low-priority': agentPerformance.slice(6).map((a) => a.name),
|
||||
};
|
||||
|
||||
console.log('Optimization recommendations:', recommendations);
|
||||
return recommendations;
|
||||
}
|
||||
|
||||
/**
|
||||
* Monitor workflow execution and provide insights
|
||||
* @param _workflowTaskId
|
||||
*/
|
||||
async monitorWorkflowExecution(_workflowTaskId: string): Promise<{
|
||||
progress: number;
|
||||
activeSteps: string[];
|
||||
completedSteps: string[];
|
||||
estimatedCompletion: Date;
|
||||
bottlenecks: string[];
|
||||
}> {
|
||||
const systemStatus = this.orchestrator.getSystemStatus();
|
||||
|
||||
// Find all tasks related to this workflow
|
||||
const workflowTasks = systemStatus.activeTasks.filter(
|
||||
(task) =>
|
||||
task.description.includes('Execute workflow:') ||
|
||||
task.description.includes('Workflow step:')
|
||||
);
|
||||
|
||||
const completedTasks = systemStatus.queuedTasks.filter(
|
||||
(task) =>
|
||||
task.status === 'completed' &&
|
||||
(task.description.includes('Execute workflow:') ||
|
||||
task.description.includes('Workflow step:'))
|
||||
);
|
||||
|
||||
const totalSteps = workflowTasks.length + completedTasks.length;
|
||||
const completedSteps = completedTasks.length;
|
||||
const progress = totalSteps > 0 ? completedSteps / totalSteps : 0;
|
||||
|
||||
// Estimate completion time
|
||||
const avgStepTime = 5000; // 5 seconds average
|
||||
const remainingSteps = totalSteps - completedSteps;
|
||||
const estimatedCompletion = new Date(
|
||||
Date.now() + remainingSteps * avgStepTime
|
||||
);
|
||||
|
||||
// Identify bottlenecks
|
||||
const bottlenecks = workflowTasks
|
||||
.filter((task) => Date.now() - (task.startTime?.getTime() || 0) > 30000)
|
||||
.map((task) => task.description);
|
||||
|
||||
return {
|
||||
progress,
|
||||
activeSteps: workflowTasks.map((t) => t.description),
|
||||
completedSteps: completedTasks.map((t) => t.description),
|
||||
estimatedCompletion,
|
||||
bottlenecks,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
export default OrchestrationManagementSkill;
|
||||
802
agents/orchestrator/skills/resource-optimizer.ts
Normal file
802
agents/orchestrator/skills/resource-optimizer.ts
Normal file
@@ -0,0 +1,802 @@
|
||||
import { Agent } from '../index';
|
||||
|
||||
/**
|
||||
* Resource Optimizer Skill
|
||||
*
|
||||
* Optimizes resource allocation and utilization across the agent system
|
||||
*/
|
||||
export class ResourceOptimizerSkill {
|
||||
private orchestrator: Agent;
|
||||
private resourcePools: Map<string, ResourcePool> = new Map();
|
||||
private allocations: Map<string, ResourceAllocation> = new Map();
|
||||
private metrics: ResourceMetrics[] = [];
|
||||
private optimizationHistory: OptimizationResult[] = [];
|
||||
|
||||
/**
|
||||
*
|
||||
* @param orchestrator
|
||||
*/
|
||||
constructor(orchestrator: Agent) {
|
||||
this.orchestrator = orchestrator;
|
||||
this.initializeResourcePools();
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize default resource pools
|
||||
*/
|
||||
private initializeResourcePools(): void {
|
||||
// CPU Resource Pool
|
||||
this.resourcePools.set('cpu', {
|
||||
id: 'cpu',
|
||||
name: 'CPU Resources',
|
||||
type: 'compute',
|
||||
total: 100,
|
||||
available: 100,
|
||||
allocated: 0,
|
||||
unit: 'percent',
|
||||
priority: 1
|
||||
});
|
||||
|
||||
// Memory Resource Pool
|
||||
this.resourcePools.set('memory', {
|
||||
id: 'memory',
|
||||
name: 'Memory Resources',
|
||||
type: 'memory',
|
||||
total: 100,
|
||||
available: 100,
|
||||
allocated: 0,
|
||||
unit: 'percent',
|
||||
priority: 1
|
||||
});
|
||||
|
||||
// Network Resource Pool
|
||||
this.resourcePools.set('network', {
|
||||
id: 'network',
|
||||
name: 'Network Resources',
|
||||
type: 'network',
|
||||
total: 1000,
|
||||
available: 1000,
|
||||
allocated: 0,
|
||||
unit: 'connections',
|
||||
priority: 2
|
||||
});
|
||||
|
||||
// Storage Resource Pool
|
||||
this.resourcePools.set('storage', {
|
||||
id: 'storage',
|
||||
name: 'Storage Resources',
|
||||
type: 'storage',
|
||||
total: 10000,
|
||||
available: 10000,
|
||||
unit: 'megabytes',
|
||||
priority: 2,
|
||||
allocated: 0
|
||||
});
|
||||
|
||||
// API Rate Limit Pool
|
||||
this.resourcePools.set('api-rate', {
|
||||
id: 'api-rate',
|
||||
name: 'API Rate Limits',
|
||||
type: 'api',
|
||||
total: 1000,
|
||||
available: 1000,
|
||||
allocated: 0,
|
||||
unit: 'requests_per_hour',
|
||||
priority: 3
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Optimize resource allocation across the system
|
||||
* @param options Optimization options
|
||||
*/
|
||||
async optimizeResources(options: OptimizationOptions = {}): Promise<OptimizationResult> {
|
||||
const startTime = Date.now();
|
||||
const optimizations: ResourceOptimization[] = [];
|
||||
|
||||
try {
|
||||
// Get current system status
|
||||
const systemStatus = this.orchestrator.getSystemStatus();
|
||||
|
||||
// Analyze current resource utilization
|
||||
const currentUtilization = this.getResourceUtilization();
|
||||
|
||||
// Identify optimization opportunities
|
||||
const opportunities = this.identifyOptimizationOpportunities(currentUtilization, systemStatus);
|
||||
|
||||
// Apply optimizations
|
||||
for (const opportunity of opportunities) {
|
||||
const optimization = await this.applyOptimization(opportunity);
|
||||
optimizations.push(optimization);
|
||||
}
|
||||
|
||||
// Rebalance resources if needed
|
||||
const rebalancing = await this.rebalanceResources();
|
||||
|
||||
const endTime = Date.now();
|
||||
const duration = endTime - startTime;
|
||||
|
||||
const result: OptimizationResult = {
|
||||
timestamp: new Date().toISOString(),
|
||||
duration,
|
||||
optimizations,
|
||||
rebalancing,
|
||||
beforeMetrics: currentUtilization,
|
||||
afterMetrics: this.getResourceUtilization(),
|
||||
impact: this.calculateOptimizationImpact(currentUtilization, optimizations)
|
||||
};
|
||||
|
||||
this.optimizationHistory.push(result);
|
||||
this.updateMetrics(result);
|
||||
|
||||
return result;
|
||||
} catch (error) {
|
||||
const endTime = Date.now();
|
||||
const duration = endTime - startTime;
|
||||
|
||||
return {
|
||||
timestamp: new Date().toISOString(),
|
||||
duration,
|
||||
optimizations: [],
|
||||
rebalancing: {
|
||||
success: false,
|
||||
reason: error.message,
|
||||
changes: []
|
||||
},
|
||||
beforeMetrics: this.getResourceUtilization(),
|
||||
afterMetrics: this.getResourceUtilization(),
|
||||
impact: {
|
||||
efficiencyGain: 0,
|
||||
resourceSavings: {},
|
||||
performanceImprovement: 0
|
||||
},
|
||||
error: error.message
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get current resource utilization
|
||||
*/
|
||||
getResourceUtilization(): ResourceUtilization {
|
||||
const pools: ResourcePoolStatus[] = [];
|
||||
|
||||
for (const [id, pool] of this.resourcePools) {
|
||||
const utilizationRate = pool.total > 0 ? (pool.allocated / pool.total) * 100 : 0;
|
||||
|
||||
pools.push({
|
||||
id: pool.id,
|
||||
name: pool.name,
|
||||
type: pool.type,
|
||||
total: pool.total,
|
||||
allocated: pool.allocated,
|
||||
available: pool.available,
|
||||
utilizationRate,
|
||||
status: this.getPoolStatus(utilizationRate),
|
||||
priority: pool.priority
|
||||
});
|
||||
}
|
||||
|
||||
const overallUtilization = pools.reduce((sum, pool) => sum + pool.utilizationRate, 0) / pools.length;
|
||||
|
||||
return {
|
||||
timestamp: new Date().toISOString(),
|
||||
pools,
|
||||
overallStatus: this.getOverallStatus(pools),
|
||||
overallUtilization,
|
||||
totalAllocations: this.allocations.size,
|
||||
efficiency: this.calculateEfficiency(pools)
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Allocate resources to a specific agent or task
|
||||
* @param recipient Resource recipient
|
||||
* @param requests Resource requests
|
||||
*/
|
||||
async allocateResources(
|
||||
recipient: string,
|
||||
requests: ResourceRequest[]
|
||||
): Promise<ResourceAllocationResult> {
|
||||
const allocationId = `alloc_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
|
||||
const allocations: ResourceAllocationDetail[] = [];
|
||||
const failedRequests: ResourceRequest[] = [];
|
||||
|
||||
// Check if we can satisfy all requests
|
||||
for (const request of requests) {
|
||||
const pool = this.resourcePools.get(request.type);
|
||||
if (!pool) {
|
||||
failedRequests.push(request);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (pool.available < request.amount) {
|
||||
failedRequests.push(request);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
if (failedRequests.length > 0) {
|
||||
return {
|
||||
success: false,
|
||||
allocationId: '',
|
||||
allocations: [],
|
||||
failedRequests,
|
||||
reason: 'Insufficient resources available'
|
||||
};
|
||||
}
|
||||
|
||||
// Allocate resources
|
||||
for (const request of requests) {
|
||||
const pool = this.resourcePools.get(request.type);
|
||||
if (!pool) continue;
|
||||
|
||||
pool.allocated += request.amount;
|
||||
pool.available = pool.total - pool.allocated;
|
||||
|
||||
allocations.push({
|
||||
type: request.type,
|
||||
amount: request.amount,
|
||||
priority: request.priority || 1,
|
||||
expiresAt: request.expiresAt || new Date(Date.now() + 3600000).toISOString(), // 1 hour default
|
||||
metadata: request.metadata || {}
|
||||
});
|
||||
}
|
||||
|
||||
const allocation: ResourceAllocation = {
|
||||
id: allocationId,
|
||||
recipient,
|
||||
allocations,
|
||||
createdAt: new Date().toISOString(),
|
||||
status: 'active'
|
||||
};
|
||||
|
||||
this.allocations.set(allocationId, allocation);
|
||||
|
||||
return {
|
||||
success: true,
|
||||
allocationId,
|
||||
allocations,
|
||||
failedRequests: []
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Release allocated resources
|
||||
* @param allocationId Allocation identifier
|
||||
*/
|
||||
async releaseResources(allocationId: string): Promise<boolean> {
|
||||
const allocation = this.allocations.get(allocationId);
|
||||
if (!allocation) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Release resources back to pools
|
||||
for (const detail of allocation.allocations) {
|
||||
const pool = this.resourcePools.get(detail.type);
|
||||
if (pool) {
|
||||
pool.allocated -= detail.amount;
|
||||
pool.available = pool.total - pool.allocated;
|
||||
}
|
||||
}
|
||||
|
||||
allocation.status = 'released';
|
||||
this.allocations.delete(allocationId);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Identify optimization opportunities
|
||||
* @param utilization Current resource utilization
|
||||
* @param systemStatus System status
|
||||
*/
|
||||
private identifyOptimizationOpportunities(
|
||||
utilization: ResourceUtilization,
|
||||
systemStatus: any
|
||||
): OptimizationOpportunity[] {
|
||||
const opportunities: OptimizationOpportunity[] = [];
|
||||
|
||||
// Check for underutilized resources
|
||||
for (const pool of utilization.pools) {
|
||||
if (pool.utilizationRate < 30 && pool.priority <= 2) {
|
||||
opportunities.push({
|
||||
type: 'underutilization',
|
||||
poolId: pool.id,
|
||||
description: `Resource pool ${pool.name} is underutilized at ${pool.utilizationRate.toFixed(1)}%`,
|
||||
potentialSavings: pool.allocated * 0.5,
|
||||
priority: 'medium',
|
||||
effort: 'low'
|
||||
});
|
||||
}
|
||||
|
||||
// Check for overutilized resources
|
||||
if (pool.utilizationRate > 80) {
|
||||
opportunities.push({
|
||||
type: 'overutilization',
|
||||
poolId: pool.id,
|
||||
description: `Resource pool ${pool.name} is overutilized at ${pool.utilizationRate.toFixed(1)}%`,
|
||||
potentialSavings: 0,
|
||||
priority: 'high',
|
||||
effort: 'medium'
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Check for expired allocations
|
||||
const now = Date.now();
|
||||
for (const [id, allocation] of this.allocations) {
|
||||
if (allocation.status === 'active') {
|
||||
for (const detail of allocation.allocations) {
|
||||
if (detail.expiresAt && new Date(detail.expiresAt).getTime() < now) {
|
||||
opportunities.push({
|
||||
type: 'expired_allocation',
|
||||
poolId: detail.type,
|
||||
description: `Expired allocation ${id} for ${allocation.recipient}`,
|
||||
potentialSavings: detail.amount,
|
||||
priority: 'medium',
|
||||
effort: 'low',
|
||||
allocationId: id
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return opportunities.sort((a, b) => {
|
||||
const priorityOrder = { high: 3, medium: 2, low: 1 };
|
||||
return (priorityOrder[b.priority] || 0) - (priorityOrder[a.priority] || 0);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply optimization
|
||||
* @param opportunity Optimization opportunity
|
||||
*/
|
||||
private async applyOptimization(opportunity: OptimizationOpportunity): Promise<ResourceOptimization> {
|
||||
const startTime = Date.now();
|
||||
|
||||
try {
|
||||
switch (opportunity.type) {
|
||||
case 'underutilization':
|
||||
return this.optimizeUnderutilizedPool(opportunity);
|
||||
case 'overutilization':
|
||||
return this.optimizeOverutilizedPool(opportunity);
|
||||
case 'expired_allocation':
|
||||
return this.releaseExpiredAllocation(opportunity);
|
||||
default:
|
||||
throw new Error(`Unknown optimization type: ${opportunity.type}`);
|
||||
}
|
||||
} catch (error) {
|
||||
const endTime = Date.now();
|
||||
return {
|
||||
type: opportunity.type,
|
||||
poolId: opportunity.poolId,
|
||||
success: false,
|
||||
duration: endTime - startTime,
|
||||
message: error.message,
|
||||
beforeState: {},
|
||||
afterState: {}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Optimize underutilized resource pool
|
||||
* @param opportunity Underutilization opportunity
|
||||
*/
|
||||
private async optimizeUnderutilizedPool(opportunity: OptimizationOpportunity): Promise<ResourceOptimization> {
|
||||
const pool = this.resourcePools.get(opportunity.poolId);
|
||||
const startTime = Date.now();
|
||||
|
||||
if (!pool) {
|
||||
throw new Error(`Resource pool ${opportunity.poolId} not found`);
|
||||
}
|
||||
|
||||
const beforeState = {
|
||||
allocated: pool.allocated,
|
||||
available: pool.available,
|
||||
utilizationRate: (pool.allocated / pool.total) * 100
|
||||
};
|
||||
|
||||
// Consolidate allocations or reduce limits
|
||||
const consolidations = await this.consolidateAllocations(opportunity.poolId);
|
||||
|
||||
const afterState = {
|
||||
allocated: pool.allocated,
|
||||
available: pool.available,
|
||||
utilizationRate: (pool.allocated / pool.total) * 100
|
||||
};
|
||||
|
||||
const endTime = Date.now();
|
||||
|
||||
return {
|
||||
type: 'underutilization',
|
||||
poolId: opportunity.poolId,
|
||||
success: true,
|
||||
duration: endTime - startTime,
|
||||
message: `Consolidated ${consolidations.length} allocations in ${pool.name}`,
|
||||
beforeState,
|
||||
afterState,
|
||||
details: { consolidations }
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Optimize overutilized resource pool
|
||||
* @param opportunity Overutilization opportunity
|
||||
*/
|
||||
private async optimizeOverutilizedPool(opportunity: OptimizationOpportunity): Promise<ResourceOptimization> {
|
||||
const pool = this.resourcePools.get(opportunity.poolId);
|
||||
const startTime = Date.now();
|
||||
|
||||
if (!pool) {
|
||||
throw new Error(`Resource pool ${opportunity.poolId} not found`);
|
||||
}
|
||||
|
||||
const beforeState = {
|
||||
allocated: pool.allocated,
|
||||
available: pool.available,
|
||||
utilizationRate: (pool.allocated / pool.total) * 100
|
||||
};
|
||||
|
||||
// Prioritize and potentially limit lower priority allocations
|
||||
const prioritizations = await this.prioritizeAllocations(opportunity.poolId);
|
||||
|
||||
const afterState = {
|
||||
allocated: pool.allocated,
|
||||
available: pool.available,
|
||||
utilizationRate: (pool.allocated / pool.total) * 100
|
||||
};
|
||||
|
||||
const endTime = Date.now();
|
||||
|
||||
return {
|
||||
type: 'overutilization',
|
||||
poolId: opportunity.poolId,
|
||||
success: true,
|
||||
duration: endTime - startTime,
|
||||
message: `Reprioritized ${prioritizations.length} allocations in ${pool.name}`,
|
||||
beforeState,
|
||||
afterState,
|
||||
details: { prioritizations }
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Release expired allocation
|
||||
* @param opportunity Expired allocation opportunity
|
||||
*/
|
||||
private async releaseExpiredAllocation(opportunity: OptimizationOpportunity): Promise<ResourceOptimization> {
|
||||
const startTime = Date.now();
|
||||
|
||||
if (!opportunity.allocationId) {
|
||||
throw new Error('Allocation ID is required for expired allocation optimization');
|
||||
}
|
||||
|
||||
const success = await this.releaseResources(opportunity.allocationId);
|
||||
|
||||
const endTime = Date.now();
|
||||
|
||||
return {
|
||||
type: 'expired_allocation',
|
||||
poolId: opportunity.poolId,
|
||||
success,
|
||||
duration: endTime - startTime,
|
||||
message: success ? `Released expired allocation ${opportunity.allocationId}` : `Failed to release allocation ${opportunity.allocationId}`,
|
||||
beforeState: {},
|
||||
afterState: {},
|
||||
details: { allocationId: opportunity.allocationId }
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Rebalance resources across pools
|
||||
*/
|
||||
private async rebalanceResources(): Promise<RebalancingResult> {
|
||||
const changes: RebalancingChange[] = [];
|
||||
|
||||
try {
|
||||
// Check for pools that can share resources
|
||||
const computePools = Array.from(this.resourcePools.values()).filter(p => p.type === 'compute');
|
||||
const memoryPools = Array.from(this.resourcePools.values()).filter(p => p.type === 'memory');
|
||||
|
||||
// Simple rebalancing logic
|
||||
for (const computePool of computePools) {
|
||||
if (computePool.utilizationRate > 80) {
|
||||
// Try to move some workload to other compute pools
|
||||
const underutilizedCompute = computePools.find(p => p.id !== computePool.id && p.utilizationRate < 50);
|
||||
if (underutilizedCompute) {
|
||||
const transferAmount = Math.min(computePool.allocated * 0.2, underutilizedCompute.available);
|
||||
if (transferAmount > 0) {
|
||||
changes.push({
|
||||
from: computePool.id,
|
||||
to: underutilizedCompute.id,
|
||||
amount: transferAmount,
|
||||
type: 'compute',
|
||||
reason: 'Load balancing'
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
success: true,
|
||||
changes,
|
||||
timestamp: new Date().toISOString()
|
||||
};
|
||||
} catch (error) {
|
||||
return {
|
||||
success: false,
|
||||
reason: error.message,
|
||||
changes: [],
|
||||
timestamp: new Date().toISOString()
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Consolidate allocations in a pool
|
||||
* @param poolId Pool identifier
|
||||
*/
|
||||
private async consolidateAllocations(poolId: string): Promise<string[]> {
|
||||
const consolidations: string[] = [];
|
||||
|
||||
// Find allocations that can be consolidated
|
||||
const poolAllocations = Array.from(this.allocations.values())
|
||||
.filter(a => a.status === 'active' && a.allocations.some(al => al.type === poolId));
|
||||
|
||||
// This is a simplified consolidation logic
|
||||
// In a real implementation, you would analyze allocation patterns
|
||||
for (const allocation of poolAllocations) {
|
||||
if (allocation.allocations.length === 1 && allocation.allocations[0].amount < 10) {
|
||||
consolidations.push(allocation.id);
|
||||
// In a real implementation, you would consolidate this allocation
|
||||
}
|
||||
}
|
||||
|
||||
return consolidations;
|
||||
}
|
||||
|
||||
/**
|
||||
* Prioritize allocations in a pool
|
||||
* @param poolId Pool identifier
|
||||
*/
|
||||
private async prioritizeAllocations(poolId: string): Promise<string[]> {
|
||||
const prioritizations: string[] = [];
|
||||
|
||||
// Find allocations for this pool
|
||||
const poolAllococations = Array.from(this.allocations.entries())
|
||||
.filter(([_, allocation]) =>
|
||||
allocation.status === 'active' &&
|
||||
allocation.allocations.some(al => al.type === poolId)
|
||||
)
|
||||
.sort(([_, a], [__, b]) => {
|
||||
const aMaxPriority = Math.max(...a.allocations.map(al => al.priority));
|
||||
const bMaxPriority = Math.max(...b.allocations.map(al => al.priority));
|
||||
return bMaxPriority - aMaxPriority; // Higher priority first
|
||||
});
|
||||
|
||||
// This is a simplified prioritization logic
|
||||
// In a real implementation, you would implement more sophisticated prioritization
|
||||
for (const [id, allocation] of poolAllococations) {
|
||||
prioritizations.push(id);
|
||||
// In a real implementation, you would adjust allocation priorities
|
||||
}
|
||||
|
||||
return prioritizations;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get pool status based on utilization rate
|
||||
* @param utilizationRate Utilization percentage
|
||||
*/
|
||||
private getPoolStatus(utilizationRate: number): 'optimal' | 'warning' | 'critical' {
|
||||
if (utilizationRate < 30) return 'warning'; // Underutilized
|
||||
if (utilizationRate > 80) return 'critical'; // Overutilized
|
||||
return 'optimal';
|
||||
}
|
||||
|
||||
/**
|
||||
* Get overall system status
|
||||
* @param pools Resource pools
|
||||
*/
|
||||
private getOverallStatus(pools: ResourcePoolStatus[]): 'optimal' | 'warning' | 'critical' {
|
||||
const criticalCount = pools.filter(p => p.status === 'critical').length;
|
||||
const warningCount = pools.filter(p => p.status === 'warning').length;
|
||||
|
||||
if (criticalCount > 0) return 'critical';
|
||||
if (warningCount > pools.length / 2) return 'warning';
|
||||
return 'optimal';
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate efficiency score
|
||||
* @param pools Resource pools
|
||||
*/
|
||||
private calculateEfficiency(pools: ResourcePoolStatus[]): number {
|
||||
const optimalPools = pools.filter(p => p.status === 'optimal').length;
|
||||
return (optimalPools / pools.length) * 100;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate optimization impact
|
||||
* @param beforeMetrics Metrics before optimization
|
||||
* @param optimizations Applied optimizations
|
||||
*/
|
||||
private calculateOptimizationImpact(
|
||||
beforeMetrics: ResourceUtilization,
|
||||
optimizations: ResourceOptimization[]
|
||||
): OptimizationImpact {
|
||||
const afterMetrics = this.getResourceUtilization();
|
||||
|
||||
const efficiencyGain = afterMetrics.efficiency - beforeMetrics.efficiency;
|
||||
|
||||
const resourceSavings: Record<string, number> = {};
|
||||
for (const opt of optimizations) {
|
||||
if (opt.success && opt.type === 'underutilization') {
|
||||
resourceSavings[opt.poolId] = (resourceSavings[opt.poolId] || 0) +
|
||||
((opt.beforeState.utilizationRate || 0) - (opt.afterState.utilizationRate || 0));
|
||||
}
|
||||
}
|
||||
|
||||
const performanceImprovement = Math.max(0, efficiencyGain * 0.5);
|
||||
|
||||
return {
|
||||
efficiencyGain,
|
||||
resourceSavings,
|
||||
performanceImprovement
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Update metrics with optimization result
|
||||
* @param result Optimization result
|
||||
*/
|
||||
private updateMetrics(result: OptimizationResult): void {
|
||||
const metric: ResourceMetrics = {
|
||||
timestamp: result.timestamp,
|
||||
efficiency: result.afterMetrics.efficiency,
|
||||
utilization: result.afterMetrics.overallUtilization,
|
||||
optimizations: result.optimizations.length,
|
||||
allocations: result.afterMetrics.totalAllocations
|
||||
};
|
||||
|
||||
this.metrics.push(metric);
|
||||
|
||||
// Keep only last 100 metrics
|
||||
if (this.metrics.length > 100) {
|
||||
this.metrics = this.metrics.slice(-100);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Type definitions
|
||||
interface ResourcePool {
|
||||
id: string;
|
||||
name: string;
|
||||
type: string;
|
||||
total: number;
|
||||
available: number;
|
||||
allocated: number;
|
||||
unit: string;
|
||||
priority: number;
|
||||
utilizationRate?: number;
|
||||
}
|
||||
|
||||
interface ResourceAllocation {
|
||||
id: string;
|
||||
recipient: string;
|
||||
allocations: ResourceAllocationDetail[];
|
||||
createdAt: string;
|
||||
status: 'active' | 'released' | 'expired';
|
||||
}
|
||||
|
||||
interface ResourceAllocationDetail {
|
||||
type: string;
|
||||
amount: number;
|
||||
priority: number;
|
||||
expiresAt: string;
|
||||
metadata: Record<string, any>;
|
||||
}
|
||||
|
||||
interface ResourceRequest {
|
||||
type: string;
|
||||
amount: number;
|
||||
priority?: number;
|
||||
expiresAt?: string;
|
||||
metadata?: Record<string, any>;
|
||||
}
|
||||
|
||||
interface ResourceAllocationResult {
|
||||
success: boolean;
|
||||
allocationId: string;
|
||||
allocations: ResourceAllocationDetail[];
|
||||
failedRequests: ResourceRequest[];
|
||||
reason?: string;
|
||||
}
|
||||
|
||||
interface ResourceUtilization {
|
||||
timestamp: string;
|
||||
pools: ResourcePoolStatus[];
|
||||
overallStatus: 'optimal' | 'warning' | 'critical';
|
||||
overallUtilization: number;
|
||||
totalAllocations: number;
|
||||
efficiency: number;
|
||||
}
|
||||
|
||||
interface ResourcePoolStatus extends ResourcePool {
|
||||
utilizationRate: number;
|
||||
status: 'optimal' | 'warning' | 'critical';
|
||||
}
|
||||
|
||||
interface OptimizationOptions {
|
||||
aggressive?: boolean;
|
||||
targetEfficiency?: number;
|
||||
maxOptimizations?: number;
|
||||
}
|
||||
|
||||
interface OptimizationOpportunity {
|
||||
type: string;
|
||||
poolId: string;
|
||||
description: string;
|
||||
potentialSavings: number;
|
||||
priority: 'high' | 'medium' | 'low';
|
||||
effort: 'low' | 'medium' | 'high';
|
||||
allocationId?: string;
|
||||
}
|
||||
|
||||
interface ResourceOptimization {
|
||||
type: string;
|
||||
poolId: string;
|
||||
success: boolean;
|
||||
duration: number;
|
||||
message: string;
|
||||
beforeState: Record<string, any>;
|
||||
afterState: Record<string, any>;
|
||||
details?: Record<string, any>;
|
||||
}
|
||||
|
||||
interface RebalancingResult {
|
||||
success: boolean;
|
||||
changes: RebalancingChange[];
|
||||
timestamp: string;
|
||||
reason?: string;
|
||||
}
|
||||
|
||||
interface RebalancingChange {
|
||||
from: string;
|
||||
to: string;
|
||||
amount: number;
|
||||
type: string;
|
||||
reason: string;
|
||||
}
|
||||
|
||||
interface OptimizationResult {
|
||||
timestamp: string;
|
||||
duration: number;
|
||||
optimizations: ResourceOptimization[];
|
||||
rebalancing: RebalancingResult;
|
||||
beforeMetrics: ResourceUtilization;
|
||||
afterMetrics: ResourceUtilization;
|
||||
impact: OptimizationImpact;
|
||||
error?: string;
|
||||
}
|
||||
|
||||
interface OptimizationImpact {
|
||||
efficiencyGain: number;
|
||||
resourceSavings: Record<string, number>;
|
||||
performanceImprovement: number;
|
||||
}
|
||||
|
||||
interface ResourceMetrics {
|
||||
timestamp: string;
|
||||
efficiency: number;
|
||||
utilization: number;
|
||||
optimizations: number;
|
||||
allocations: number;
|
||||
}
|
||||
|
||||
// Default export for test compatibility
|
||||
export default ResourceOptimizerSkill;
|
||||
18
agents/orchestrator/tsconfig.json
Normal file
18
agents/orchestrator/tsconfig.json
Normal file
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"target": "ES2022",
|
||||
"module": "ESNext",
|
||||
"moduleResolution": "bundler",
|
||||
"allowSyntheticDefaultImports": true,
|
||||
"esModuleInterop": true,
|
||||
"allowJs": true,
|
||||
"strict": true,
|
||||
"skipLibCheck": true,
|
||||
"declaration": true,
|
||||
"outDir": "./dist",
|
||||
"rootDir": "./src"
|
||||
},
|
||||
"include": ["**/*.ts", "**/*.tsx"],
|
||||
"exclude": [
|
||||
"../../../agents/orchestrator/node_modules", "dist"]
|
||||
}
|
||||
85
plugin.lock.json
Normal file
85
plugin.lock.json
Normal file
@@ -0,0 +1,85 @@
|
||||
{
|
||||
"$schema": "internal://schemas/plugin.lock.v1.json",
|
||||
"pluginId": "gh:menoncello/menon-market:plugins/menon-core",
|
||||
"normalized": {
|
||||
"repo": null,
|
||||
"ref": "refs/tags/v20251128.0",
|
||||
"commit": "9fbe95923df831e454343859f9e79e3b161e0fc8",
|
||||
"treeHash": "cc31ca70bd7975cda8f8681d40b07572df16e740954d63cfa2009c57f4658c8c",
|
||||
"generatedAt": "2025-11-28T10:27:04.455425Z",
|
||||
"toolVersion": "publish_plugins.py@0.2.0"
|
||||
},
|
||||
"origin": {
|
||||
"remote": "git@github.com:zhongweili/42plugin-data.git",
|
||||
"branch": "master",
|
||||
"commit": "aa1497ed0949fd50e99e70d6324a29c5b34f9390",
|
||||
"repoRoot": "/Users/zhongweili/projects/openmind/42plugin-data"
|
||||
},
|
||||
"manifest": {
|
||||
"name": "menon-core",
|
||||
"description": "Core functionality plugin for the menon ecosystem with feature management and configuration capabilities.",
|
||||
"version": "1.0.0"
|
||||
},
|
||||
"content": {
|
||||
"files": [
|
||||
{
|
||||
"path": "README.md",
|
||||
"sha256": "dc106a6b415ebd2629f95625abc58bb88f3f5512896b9ade4434d88d19937e04"
|
||||
},
|
||||
{
|
||||
"path": "agents/orchestrator/index.test.ts",
|
||||
"sha256": "8941f58916a72c4bcaa33b8f316ea54f11726295136cde309851fff59588fb5c"
|
||||
},
|
||||
{
|
||||
"path": "agents/orchestrator/README.md",
|
||||
"sha256": "3722e0b386c1a8e553a81d291d07d4028509b01aa16943ccd131eae54bef2e54"
|
||||
},
|
||||
{
|
||||
"path": "agents/orchestrator/dynamic-discovery.ts",
|
||||
"sha256": "3c8292e2c4546114c21a74a4bbdd01d520cc75a71dbae573b303953b9a67d070"
|
||||
},
|
||||
{
|
||||
"path": "agents/orchestrator/package.json",
|
||||
"sha256": "00b4cfc2f231bffea5ca489acda0dc763c9a3e6da5d2719263fdbb102e7cd3e1"
|
||||
},
|
||||
{
|
||||
"path": "agents/orchestrator/SKILL.md",
|
||||
"sha256": "bff0453704d88e2a03ee7b88f55a113c03d77d793b0afdf7d3358aa70900e5aa"
|
||||
},
|
||||
{
|
||||
"path": "agents/orchestrator/.prettierrc",
|
||||
"sha256": "b707eeb2c8bf66aaf90a23e4a4ba05f0fd0153a60b2e664b447880cfa4e92097"
|
||||
},
|
||||
{
|
||||
"path": "agents/orchestrator/tsconfig.json",
|
||||
"sha256": "e964283bea292590cd3341552e7213bf18f409ed0d36f2351906bccc8ac38f28"
|
||||
},
|
||||
{
|
||||
"path": "agents/orchestrator/index.ts",
|
||||
"sha256": "3a8dd48998ac17b0e4cce04ffe8bffe9c8f1235f775808fbc4dcd96924c8dd39"
|
||||
},
|
||||
{
|
||||
"path": "agents/orchestrator/agent-config.json",
|
||||
"sha256": "b877e957b8c358db1bbcff5f4ec7bd0334815700027c0482488350b64d80ca89"
|
||||
},
|
||||
{
|
||||
"path": "agents/orchestrator/skills/resource-optimizer.ts",
|
||||
"sha256": "a9495bd151d0ddb6d7e12c13ab8c073ec7a6f80f20985c82ba5a4dd6d658ecf5"
|
||||
},
|
||||
{
|
||||
"path": "agents/orchestrator/skills/orchestration-management.ts",
|
||||
"sha256": "7469b0c84b28a1a01be9005c9aaa00f3196f4fd84634dc5b644ce512b7aba1ed"
|
||||
},
|
||||
{
|
||||
"path": ".claude-plugin/plugin.json",
|
||||
"sha256": "d7444df657a0686ecd4b0fa7c4184253f4393fded5ede0fc367bddcf701ce95a"
|
||||
}
|
||||
],
|
||||
"dirSha256": "cc31ca70bd7975cda8f8681d40b07572df16e740954d63cfa2009c57f4658c8c"
|
||||
},
|
||||
"security": {
|
||||
"scannedAt": null,
|
||||
"scannerVersion": null,
|
||||
"flags": []
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user