@sethdouglasford/claude-flow
Version:
Claude Code Flow - Advanced AI-powered development workflows with SPARC methodology
266 lines (256 loc) • 11.1 kB
JavaScript
import { logger } from "../../core/logger.js";
/**
* Optimization Strategy - Performance optimization with coordinated analysis and improvements
* Based on the Optimization Swarm Pattern from swarm documentation
*
* Features:
* - Performance profiling
* - Bottleneck identification
* - Optimization implementation
* - Validation and testing
*/
export class OptimizationStrategy {
async decomposeObjective(objective) {
logger.info(`Decomposing optimization objective: ${objective.description}`);
const timestamp = Date.now();
const tasks = [];
const dependencies = new Map();
// 1. Performance Profiling and Analysis
const profilingTaskId = `profiling-${timestamp}`;
tasks.push({
id: {
id: profilingTaskId,
swarmId: objective.id,
sequence: 1,
priority: 1,
},
name: "Performance Profiling",
description: "Profile system performance and identify metrics",
status: "created",
priority: "high",
type: "analysis",
requirements: {
capabilities: ["performance_profiling", "monitoring", "metrics_analysis"],
tools: ["memory", "profiling_tools", "monitoring_tools"],
permissions: ["read", "write", "execute"],
},
constraints: {
dependencies: [],
dependents: [],
conflicts: [],
},
input: { objective: objective.description, phase: "profiling" },
instructions: `
Profile performance for: ${objective.description}
Tasks:
1. Setup performance monitoring and profiling tools
2. Collect baseline performance metrics (CPU, memory, I/O, network)
3. Identify performance bottlenecks and resource constraints
4. Store profiling data in Memory under 'performance_baseline'
5. Create TodoWrite tasks for bottleneck analysis
Coordination:
- Establish performance benchmarks and targets
- Document current system behavior and resource usage
- Identify critical performance paths
- Create performance monitoring dashboard
`,
context: { strategy: "optimization", coordination: "performance_profiler" },
createdAt: new Date(),
updatedAt: new Date(),
attempts: [],
statusHistory: [],
});
// 2. Bottleneck Identification (depends on profiling)
const bottleneckTaskId = `bottleneck-analysis-${timestamp}`;
tasks.push({
id: {
id: bottleneckTaskId,
swarmId: objective.id,
sequence: 2,
priority: 1,
},
name: "Bottleneck Analysis",
description: "Identify and prioritize performance bottlenecks",
status: "created",
priority: "high",
type: "analysis",
requirements: {
capabilities: ["bottleneck_analysis", "performance_analysis", "root_cause_analysis"],
tools: ["memory", "analysis_tools", "profiling_tools"],
permissions: ["read", "write"],
},
constraints: {
dependencies: [],
dependents: [],
conflicts: [],
},
input: { objective: objective.description, phase: "bottleneck_analysis" },
instructions: `
Analyze bottlenecks for: ${objective.description}
Tasks:
1. Retrieve performance data from Memory 'performance_baseline'
2. Identify top performance bottlenecks and their impact
3. Prioritize optimization opportunities by impact vs effort
4. Store bottleneck analysis in Memory under 'bottleneck_analysis'
5. Create TodoWrite tasks for optimization planning
Coordination:
- Rank bottlenecks by performance impact and fix complexity
- Identify quick wins vs long-term improvements
- Estimate optimization effort and expected gains
- Create optimization roadmap with priorities
`,
context: { strategy: "optimization", coordination: "bottleneck_analyzer" },
createdAt: new Date(),
updatedAt: new Date(),
attempts: [],
statusHistory: [],
});
// 3. Code Optimization (parallel tracks)
const codeOptimizationTaskId = `code-optimization-${timestamp}`;
tasks.push({
id: {
id: codeOptimizationTaskId,
swarmId: objective.id,
sequence: 3,
priority: 2,
},
name: "Code Optimization",
description: "Implement code-level performance optimizations",
status: "created",
priority: "normal",
type: "coding",
requirements: {
capabilities: ["code_optimization", "algorithm_optimization", "refactoring"],
tools: ["memory", "code_analysis_tools", "batch_operations"],
permissions: ["read", "write", "create"],
},
constraints: {
dependencies: [],
dependents: [],
conflicts: [],
},
input: { objective: objective.description, phase: "code_optimization" },
instructions: `
Optimize code for: ${objective.description}
Tasks:
1. Retrieve bottleneck analysis from Memory 'bottleneck_analysis'
2. Implement algorithm optimizations and code improvements
3. Optimize data structures and memory usage
4. Store optimization changes in Memory under 'code_optimizations'
5. Create TodoWrite tasks for optimization testing
Coordination:
- Focus on high-impact, low-risk optimizations first
- Maintain code readability and maintainability
- Document optimization rationale and trade-offs
- Coordinate with infrastructure optimization team
`,
context: { strategy: "optimization", coordination: "code_optimizer" },
createdAt: new Date(),
updatedAt: new Date(),
attempts: [],
statusHistory: [],
});
// 4. Infrastructure Optimization (parallel with code optimization)
const infraOptimizationTaskId = `infra-optimization-${timestamp}`;
tasks.push({
id: {
id: infraOptimizationTaskId,
swarmId: objective.id,
sequence: 3,
priority: 2,
},
name: "Infrastructure Optimization",
description: "Optimize infrastructure and system configuration",
status: "created",
priority: "normal",
type: "optimization",
requirements: {
capabilities: ["infrastructure_optimization", "system_tuning", "caching"],
tools: ["memory", "infrastructure_tools", "configuration_tools"],
permissions: ["read", "write", "configure"],
},
constraints: {
dependencies: [],
dependents: [],
conflicts: [],
},
input: { objective: objective.description, phase: "infrastructure_optimization" },
instructions: `
Optimize infrastructure for: ${objective.description}
Tasks:
1. Retrieve bottleneck analysis from Memory 'bottleneck_analysis'
2. Implement caching strategies and database optimizations
3. Configure system parameters and resource allocation
4. Store infrastructure changes in Memory under 'infra_optimizations'
5. Create TodoWrite tasks for infrastructure testing
Coordination:
- Implement caching at multiple levels (application, database, CDN)
- Optimize database queries and indexing
- Configure load balancing and auto-scaling
- Coordinate with code optimization team for end-to-end improvements
`,
context: { strategy: "optimization", coordination: "infra_optimizer" },
createdAt: new Date(),
updatedAt: new Date(),
attempts: [],
statusHistory: [],
});
// 5. Validation and Testing (depends on all optimizations)
const validationTaskId = `optimization-validation-${timestamp}`;
tasks.push({
id: {
id: validationTaskId,
swarmId: objective.id,
sequence: 4,
priority: 1,
},
name: "Optimization Validation",
description: "Validate optimization results and measure improvements",
status: "created",
priority: "high",
type: "testing",
requirements: {
capabilities: ["performance_testing", "validation", "benchmarking"],
tools: ["memory", "testing_tools", "benchmarking_tools"],
permissions: ["read", "write", "execute"],
},
constraints: {
dependencies: [],
dependents: [],
conflicts: [],
},
input: { objective: objective.description, phase: "validation" },
instructions: `
Validate optimizations for: ${objective.description}
Tasks:
1. Retrieve all optimization changes from Memory
2. Run performance tests and benchmarks
3. Compare results against baseline performance
4. Store validation results in Memory under 'optimization_results'
5. Create TodoWrite tasks for result reporting
Coordination:
- Measure actual performance improvements vs targets
- Validate that optimizations don't introduce regressions
- Test under various load conditions and scenarios
- Document performance gains and any trade-offs
`,
context: { strategy: "optimization", coordination: "optimization_validator" },
createdAt: new Date(),
updatedAt: new Date(),
attempts: [],
statusHistory: [],
});
// Set up dependencies
dependencies.set(bottleneckTaskId, [profilingTaskId]);
dependencies.set(codeOptimizationTaskId, [bottleneckTaskId]);
dependencies.set(infraOptimizationTaskId, [bottleneckTaskId]);
dependencies.set(validationTaskId, [codeOptimizationTaskId, infraOptimizationTaskId]);
logger.info(`Created ${tasks.length} optimization tasks with dependencies`);
return {
tasks,
dependencies,
estimatedDuration: 90, // 1.5 hours for typical optimization task
};
}
}
//# sourceMappingURL=optimization.js.map