@dragonflymcp/plugin 1.0.0

package/templates/skills/performance-estimation.md.template

@@ -0,0 +1,325 @@
+---
+name: Performance Estimation
+description: Estimate computational complexity and runtime performance of implementations
+version: 1.0.0
+author: Zen Framework
+applies_to:
+  - architecture-concept
+trigger_keywords:
+  - performance
+  - complexity
+  - big o
+  - optimization
+  - scalability
+  - bottleneck
+priority: P3
+impact: medium
+---
+
+# Performance Estimation Skill
+
+## Purpose
+
+Enable the Architecture Concept agent to estimate computational complexity, identify performance bottlenecks, and recommend optimizations.
+
+## Complexity Analysis Framework
+
+### 1. Big O Classification
+
+```yaml
+complexity_classes:
+  O(1):
+    name: "Constant"
+    examples:
+      - array_index_access
+      - hash_table_lookup
+      - stack_push_pop
+    characteristics: "Time doesn't grow with input"
+    
+  O(log n):
+    name: "Logarithmic"
+    examples:
+      - binary_search
+      - balanced_tree_operations
+      - divide_and_conquer
+    characteristics: "Halves problem each step"
+    
+  O(n):
+    name: "Linear"
+    examples:
+      - array_iteration
+      - linear_search
+      - single_loop
+    characteristics: "Examines each element once"
+    
+  O(n log n):
+    name: "Linearithmic"
+    examples:
+      - efficient_sorting (merge, quick, heap)
+      - divide_and_conquer_with_merge
+    characteristics: "Best comparison-based sort"
+    
+  O(n²):
+    name: "Quadratic"
+    examples:
+      - nested_loops
+      - bubble_sort
+      - selection_sort
+    characteristics: "Pairs of elements compared"
+    warning: "Problematic for n > 10,000"
+    
+  O(n³):
+    name: "Cubic"
+    examples:
+      - matrix_multiplication_naive
+      - triple_nested_loops
+    characteristics: "Triplets examined"
+    warning: "Problematic for n > 1,000"
+    
+  O(2^n):
+    name: "Exponential"
+    examples:
+      - recursive_fibonacci_naive
+      - power_set
+      - subset_sum_brute
+    characteristics: "Doubles each step"
+    warning: "Impractical for n > 30"
+    
+  O(n!):
+    name: "Factorial"
+    examples:
+      - permutations
+      - traveling_salesman_brute
+    characteristics: "All orderings"
+    warning: "Impractical for n > 12"
+```
+
+### 2. Pattern Recognition Rules
+
+```yaml
+complexity_patterns:
+  loops:
+    single_loop_n_iterations:
+      pattern: "for i in range(n)"
+      complexity: "O(n)"
+      
+    nested_loops_independent:
+      pattern: "for i in n: for j in m"
+      complexity: "O(n * m)"
+      
+    nested_loops_dependent:
+      pattern: "for i in n: for j in range(i)"
+      complexity: "O(n²/2) = O(n²)"
+      
+    loop_with_divide:
+      pattern: "while n > 0: n = n // 2"
+      complexity: "O(log n)"
+      
+  recursion:
+    linear_recursion:
+      pattern: "f(n) = f(n-1) + O(1)"
+      complexity: "O(n)"
+      
+    binary_recursion:
+      pattern: "f(n) = 2*f(n/2) + O(1)"
+      complexity: "O(n)"
+      
+    divide_and_conquer:
+      pattern: "f(n) = 2*f(n/2) + O(n)"
+      complexity: "O(n log n)"
+      
+    exponential_recursion:
+      pattern: "f(n) = f(n-1) + f(n-2)"
+      complexity: "O(2^n)"
+```
+
+### 3. Space Complexity Analysis
+
+```yaml
+space_factors:
+  input_storage:
+    description: "Memory for input data"
+    consideration: "Often excluded (auxiliary space)"
+    
+  auxiliary_space:
+    description: "Extra memory used by algorithm"
+    examples:
+      in_place: "O(1) - modifies input"
+      linear_buffer: "O(n) - creates copy"
+      recursion_stack: "O(depth) - call stack"
+      
+  common_patterns:
+    hash_set_for_lookup: "O(n)"
+    recursion_depth: "O(log n) to O(n)"
+    dp_table: "O(n) or O(n²)"
+    graph_adjacency_list: "O(V + E)"
+```
+
+### 4. Performance Estimation Template
+
+```yaml
+estimation_template:
+  operation: "{operation_name}"
+  
+  time_complexity:
+    best_case: "O(?)"
+    average_case: "O(?)"
+    worst_case: "O(?)"
+    amortized: "O(?) if applicable"
+    
+  space_complexity:
+    auxiliary: "O(?)"
+    total: "O(?)"
+    
+  scalability_analysis:
+    n_100: "~{time}ms"
+    n_1000: "~{time}ms"
+    n_10000: "~{time}ms"
+    n_100000: "~{time}ms"
+    
+  bottleneck_identification:
+    - location: "line X"
+      issue: "nested loop"
+      impact: "O(n²)"
+      
+  optimization_opportunities:
+    - technique: "Use hash map"
+      before: "O(n²)"
+      after: "O(n)"
+      tradeoff: "+O(n) space"
+```
+
+### 5. Real-World Performance Factors
+
+```yaml
+practical_considerations:
+  constant_factors:
+    description: "Big O hides constant multipliers"
+    example: "O(n) with 100x constant vs O(n²) for small n"
+    guidance: "Profile for actual workloads"
+    
+  cache_effects:
+    description: "Memory access patterns matter"
+    examples:
+      cache_friendly: "Sequential array access"
+      cache_hostile: "Random memory jumps, linked lists"
+    impact: "10-100x performance difference"
+    
+  io_bound_vs_cpu_bound:
+    io_bound:
+      bottleneck: "Disk, network, database"
+      optimization: "Async, batching, caching"
+    cpu_bound:
+      bottleneck: "Computation"
+      optimization: "Algorithm improvement, parallelization"
+      
+  jit_effects:
+    description: "Runtime compilation impacts"
+    cold_start: "First execution slower"
+    warm: "Optimized code paths"
+```
+
+### 6. Database Query Complexity
+
+```yaml
+query_complexity:
+  table_scan:
+    complexity: "O(n)"
+    when: "No index, WHERE on non-indexed column"
+    
+  index_lookup:
+    complexity: "O(log n)"
+    when: "B-tree index on filtered column"
+    
+  hash_index:
+    complexity: "O(1)"
+    when: "Hash index, equality check"
+    
+  join_operations:
+    nested_loop: "O(n * m)"
+    hash_join: "O(n + m)"
+    merge_join: "O(n log n + m log m)"
+    
+  common_issues:
+    n_plus_1:
+      pattern: "Query in loop"
+      complexity: "O(n) queries"
+      fix: "Eager loading, JOIN"
+      
+    missing_index:
+      symptom: "Slow WHERE clause"
+      fix: "Add appropriate index"
+```
+
+### 7. Optimization Recommendations
+
+```yaml
+optimization_catalog:
+  algorithm_level:
+    - pattern: "O(n²) nested search"
+      optimization: "Use hash set for O(1) lookup"
+      result: "O(n)"
+      
+    - pattern: "Repeated subproblem computation"
+      optimization: "Memoization / Dynamic Programming"
+      result: "Polynomial instead of exponential"
+      
+    - pattern: "Full sort for top-k"
+      optimization: "Use heap / quickselect"
+      result: "O(n log k) instead of O(n log n)"
+      
+  data_structure_level:
+    - pattern: "Frequent membership checks in list"
+      optimization: "Convert to set"
+      result: "O(1) instead of O(n)"
+      
+    - pattern: "Frequent insertions in sorted list"
+      optimization: "Use balanced tree"
+      result: "O(log n) instead of O(n)"
+      
+  system_level:
+    - pattern: "Sequential API calls"
+      optimization: "Parallelize / batch"
+      result: "Wall time reduced"
+      
+    - pattern: "Repeated expensive computation"
+      optimization: "Cache results"
+      result: "Amortized O(1)"
+```
+
+## Output Format
+
+```yaml
+performance_analysis:
+  function: "processOrders"
+  file: "src/services/order.ts"
+  
+  complexity:
+    time:
+      overall: "O(n * m)"
+      breakdown:
+        - operation: "outer loop"
+          complexity: "O(n)"
+        - operation: "inner lookup"
+          complexity: "O(m)"
+          note: "Could be O(1) with index"
+    space: "O(n)"
+    
+  estimated_performance:
+    current:
+      n_1000: "~150ms"
+      n_10000: "~15s"
+      n_100000: "~25min"
+    optimized:
+      n_1000: "~5ms"
+      n_10000: "~50ms"
+      n_100000: "~500ms"
+      
+  recommendations:
+    - priority: "high"
+      issue: "Linear search in inner loop"
+      location: "line 45"
+      optimization: "Pre-build lookup map"
+      impact: "O(n * m) → O(n + m)"
+      effort: "1 hour"
+```

package/templates/skills/performance-testing-patterns.md.template

@@ -0,0 +1,341 @@
+---
+name: Performance Testing Patterns
+description: Load testing, stress testing, and performance benchmarking strategies
+version: 1.0.0
+author: Zen Framework
+applies_to:
+  - quality-concept
+trigger_keywords:
+  - performance test
+  - load test
+  - stress test
+  - benchmark
+  - scalability
+  - throughput
+priority: P3
+impact: medium
+---
+
+# Performance Testing Patterns Skill
+
+## Purpose
+
+Enable the Quality Concept agent to design and execute comprehensive performance testing strategies.
+
+## Performance Testing Framework
+
+### 1. Test Types
+
+```yaml
+performance_test_types:
+  load_testing:
+    purpose: "Verify system under expected load"
+    approach: "Gradually increase load to expected levels"
+    metrics: ["response_time", "throughput", "error_rate"]
+    duration: "15-60 minutes"
+    
+  stress_testing:
+    purpose: "Find breaking point"
+    approach: "Increase load until failure"
+    metrics: ["failure_point", "recovery_behavior", "degradation_pattern"]
+    duration: "Until failure + recovery"
+    
+  spike_testing:
+    purpose: "Test sudden traffic bursts"
+    approach: "Sudden extreme load increase"
+    metrics: ["response_time_spike", "recovery_time", "error_handling"]
+    duration: "Short bursts (5-10 min)"
+    
+  endurance_testing:
+    purpose: "Detect memory leaks, resource exhaustion"
+    approach: "Sustained load over extended period"
+    metrics: ["memory_usage", "connection_pools", "disk_usage"]
+    duration: "4-24+ hours"
+    
+  scalability_testing:
+    purpose: "Verify horizontal/vertical scaling"
+    approach: "Add resources, measure improvement"
+    metrics: ["linear_scalability", "scaling_efficiency"]
+    duration: "Varies by scaling approach"
+```
+
+### 2. Key Performance Indicators
+
+```yaml
+performance_metrics:
+  response_time:
+    percentiles:
+      p50: "Median response time"
+      p90: "90th percentile"
+      p95: "95th percentile"
+      p99: "99th percentile"
+    thresholds:
+      excellent: "<100ms"
+      good: "<300ms"
+      acceptable: "<1s"
+      poor: ">1s"
+      
+  throughput:
+    measures:
+      requests_per_second: "Total RPS"
+      transactions_per_second: "Business TPS"
+      concurrent_users: "Active users"
+    baseline: "Compare to requirements"
+    
+  error_rate:
+    calculation: "errors / total_requests * 100"
+    acceptable: "<1%"
+    concerning: "1-5%"
+    critical: ">5%"
+    
+  resource_utilization:
+    cpu: "Target <70% under load"
+    memory: "Target <80% under load"
+    network: "Bandwidth utilization"
+    disk_io: "IOPS and latency"
+```
+
+### 3. Test Scenario Design
+
+```yaml
+scenario_template:
+  name: "User Login Flow"
+  description: "Simulate user authentication"
+  
+  think_time:
+    min: 1000  # ms
+    max: 5000
+    distribution: "gaussian"
+    
+  steps:
+    - action: "Load login page"
+      expected_response: "<200ms"
+      
+    - action: "Submit credentials"
+      expected_response: "<500ms"
+      data_source: "users.csv"
+      
+    - action: "Navigate to dashboard"
+      expected_response: "<300ms"
+      
+  assertions:
+    - "response_time < 1000ms"
+    - "status_code == 200"
+    - "body contains 'Welcome'"
+```
+
+### 4. Load Profile Patterns
+
+```yaml
+load_profiles:
+  ramp_up:
+    description: "Gradual increase"
+    pattern: |
+      Users
+      ^
+      |    ___________
+      |   /
+      |  /
+      | /
+      +---------------> Time
+    use_case: "Standard load test"
+    
+  step_ladder:
+    description: "Incremental steps"
+    pattern: |
+      Users
+      ^
+      |       _____
+      |    __|
+      | __|
+      +---------------> Time
+    use_case: "Finding capacity limits"
+    
+  spike:
+    description: "Sudden burst"
+    pattern: |
+      Users
+      ^
+      |    __
+      |   |  |
+      |___|  |___
+      +---------------> Time
+    use_case: "Flash sale simulation"
+    
+  soak:
+    description: "Sustained load"
+    pattern: |
+      Users
+      ^
+      |_______________
+      |
+      +---------------> Time
+    use_case: "Memory leak detection"
+```
+
+### 5. Tool Configuration Templates
+
+```yaml
+k6_config:
+  script: |
+    import http from 'k6/http';
+    import { check, sleep } from 'k6';
+    
+    export const options = {
+      stages: [
+        { duration: '2m', target: 100 },   // Ramp up
+        { duration: '5m', target: 100 },   // Stay at 100
+        { duration: '2m', target: 200 },   // Ramp up more
+        { duration: '5m', target: 200 },   // Stay at 200
+        { duration: '2m', target: 0 },     // Ramp down
+      ],
+      thresholds: {
+        http_req_duration: ['p(95)<500'],
+        http_req_failed: ['rate<0.01'],
+      },
+    };
+    
+    export default function() {
+      const res = http.get('https://api.example.com/endpoint');
+      check(res, {
+        'status is 200': (r) => r.status === 200,
+        'response time < 500ms': (r) => r.timings.duration < 500,
+      });
+      sleep(1);
+    }
+
+jmeter_config:
+  thread_group:
+    users: 100
+    ramp_up: 60  # seconds
+    duration: 300
+    
+  http_sampler:
+    protocol: "https"
+    server: "api.example.com"
+    path: "/endpoint"
+    method: "GET"
+    
+  assertions:
+    - response_time: 500
+    - response_code: 200
+```
+
+### 6. Environment Considerations
+
+```yaml
+environment_setup:
+  production_like:
+    importance: "Critical for valid results"
+    aspects:
+      - same_hardware_specs
+      - same_network_topology
+      - same_database_size
+      - same_configuration
+      
+  data_preparation:
+    realistic_data_volume: true
+    anonymized_production_data: "preferred"
+    synthetic_data: "if needed"
+    
+  isolation:
+    dedicated_environment: true
+    no_other_traffic: true
+    monitoring_overhead: "minimal"
+    
+  baseline_establishment:
+    measure_without_load: true
+    document_resource_usage: true
+```
+
+### 7. Results Analysis
+
+```yaml
+analysis_template:
+  summary:
+    test_name: "API Load Test"
+    date: "2024-01-15"
+    duration: "30 minutes"
+    peak_users: 500
+    
+  results:
+    throughput:
+      average_rps: 850
+      peak_rps: 1200
+      
+    response_times:
+      p50: 120  # ms
+      p90: 280
+      p95: 450
+      p99: 890
+      
+    errors:
+      total: 45
+      rate: 0.3%
+      types:
+        timeout: 30
+        server_error: 15
+        
+    resources:
+      cpu_max: 72%
+      memory_max: 68%
+      db_connections_max: 85
+      
+  bottlenecks:
+    - component: "Database"
+      evidence: "Query time increased at 400 users"
+      recommendation: "Add read replica"
+      
+  pass_fail:
+    status: "PASS"
+    criteria_met:
+      - "p95 < 500ms ✓"
+      - "Error rate < 1% ✓"
+      - "Throughput > 500 RPS ✓"
+```
+
+### 8. Continuous Performance Testing
+
+```yaml
+ci_integration:
+  trigger: "On merge to main"
+  
+  quick_test:
+    duration: "5 minutes"
+    users: 50
+    purpose: "Catch regressions"
+    
+  comparison:
+    baseline: "Previous release"
+    threshold: "10% degradation = fail"
+    
+  reporting:
+    store_results: true
+    trend_analysis: true
+    alert_on_regression: true
+```
+
+## Output Format
+
+```yaml
+performance_test_report:
+  test_summary:
+    name: "Checkout Flow Load Test"
+    status: "PASSED with warnings"
+    
+  key_findings:
+    - finding: "Response time degradation above 300 users"
+      severity: "warning"
+      recommendation: "Scale horizontally before launch"
+      
+  detailed_metrics:
+    # Full metrics breakdown
+    
+  recommendations:
+    immediate:
+      - "Add database connection pooling"
+    before_launch:
+      - "Implement caching for product catalog"
+    future:
+      - "Consider CDN for static assets"
+```