@ngxtm/devkit 3.0.2 → 3.1.0

package/skills/context-optimization/SKILL.md

@@ -0,0 +1,186 @@
+---
+name: context-optimization
+description: "Apply compaction, masking, and caching strategies"
+source: "https://github.com/muratcankoylan/Agent-Skills-for-Context-Engineering/tree/main/skills/context-optimization"
+risk: safe
+---
+
+## When to Use This Skill
+
+Apply compaction, masking, and caching strategies
+
+Use this skill when working with apply compaction, masking, and caching strategies.
+# Context Optimization Techniques
+
+Context optimization extends the effective capacity of limited context windows through strategic compression, masking, caching, and partitioning. The goal is not to magically increase context windows but to make better use of available capacity. Effective optimization can double or triple effective context capacity without requiring larger models or longer contexts.
+
+## When to Activate
+
+Activate this skill when:
+- Context limits constrain task complexity
+- Optimizing for cost reduction (fewer tokens = lower costs)
+- Reducing latency for long conversations
+- Implementing long-running agent systems
+- Needing to handle larger documents or conversations
+- Building production systems at scale
+
+## Core Concepts
+
+Context optimization extends effective capacity through four primary strategies: compaction (summarizing context near limits), observation masking (replacing verbose outputs with references), KV-cache optimization (reusing cached computations), and context partitioning (splitting work across isolated contexts).
+
+The key insight is that context quality matters more than quantity. Optimization preserves signal while reducing noise. The art lies in selecting what to keep versus what to discard, and when to apply each technique.
+
+## Detailed Topics
+
+### Compaction Strategies
+
+**What is Compaction**
+Compaction is the practice of summarizing context contents when approaching limits, then reinitializing a new context window with the summary. This distills the contents of a context window in a high-fidelity manner, enabling the agent to continue with minimal performance degradation.
+
+Compaction typically serves as the first lever in context optimization. The art lies in selecting what to keep versus what to discard.
+
+**Compaction Implementation**
+Compaction works by identifying sections that can be compressed, generating summaries that capture essential points, and replacing full content with summaries. Priority for compression goes to tool outputs (replace with summaries), old turns (summarize early conversation), retrieved docs (summarize if recent versions exist), and never compress system prompt.
+
+**Summary Generation**
+Effective summaries preserve different elements depending on message type:
+
+Tool outputs: Preserve key findings, metrics, and conclusions. Remove verbose raw output.
+
+Conversational turns: Preserve key decisions, commitments, and context shifts. Remove filler and back-and-forth.
+
+Retrieved documents: Preserve key facts and claims. Remove supporting evidence and elaboration.
+
+### Observation Masking
+
+**The Observation Problem**
+Tool outputs can comprise 80%+ of token usage in agent trajectories. Much of this is verbose output that has already served its purpose. Once an agent has used a tool output to make a decision, keeping the full output provides diminishing value while consuming significant context.
+
+Observation masking replaces verbose tool outputs with compact references. The information remains accessible if needed but does not consume context continuously.
+
+**Masking Strategy Selection**
+Not all observations should be masked equally:
+
+Never mask: Observations critical to current task, observations from the most recent turn, observations used in active reasoning.
+
+Consider masking: Observations from 3+ turns ago, verbose outputs with key points extractable, observations whose purpose has been served.
+
+Always mask: Repeated outputs, boilerplate headers/footers, outputs already summarized in conversation.
+
+### KV-Cache Optimization
+
+**Understanding KV-Cache**
+The KV-cache stores Key and Value tensors computed during inference, growing linearly with sequence length. Caching the KV-cache across requests sharing identical prefixes avoids recomputation.
+
+Prefix caching reuses KV blocks across requests with identical prefixes using hash-based block matching. This dramatically reduces cost and latency for requests with common prefixes like system prompts.
+
+**Cache Optimization Patterns**
+Optimize for caching by reordering context elements to maximize cache hits. Place stable elements first (system prompt, tool definitions), then frequently reused elements, then unique elements last.
+
+Design prompts to maximize cache stability: avoid dynamic content like timestamps, use consistent formatting, keep structure stable across sessions.
+
+### Context Partitioning
+
+**Sub-Agent Partitioning**
+The most aggressive form of context optimization is partitioning work across sub-agents with isolated contexts. Each sub-agent operates in a clean context focused on its subtask without carrying accumulated context from other subtasks.
+
+This approach achieves separation of concerns—the detailed search context remains isolated within sub-agents while the coordinator focuses on synthesis and analysis.
+
+**Result Aggregation**
+Aggregate results from partitioned subtasks by validating all partitions completed, merging compatible results, and summarizing if still too large.
+
+### Budget Management
+
+**Context Budget Allocation**
+Design explicit context budgets. Allocate tokens to categories: system prompt, tool definitions, retrieved docs, message history, and reserved buffer. Monitor usage against budget and trigger optimization when approaching limits.
+
+**Trigger-Based Optimization**
+Monitor signals for optimization triggers: token utilization above 80%, degradation indicators, and performance drops. Apply appropriate optimization techniques based on context composition.
+
+## Practical Guidance
+
+### Optimization Decision Framework
+
+When to optimize:
+- Context utilization exceeds 70%
+- Response quality degrades as conversations extend
+- Costs increase due to long contexts
+- Latency increases with conversation length
+
+What to apply:
+- Tool outputs dominate: observation masking
+- Retrieved documents dominate: summarization or partitioning
+- Message history dominates: compaction with summarization
+- Multiple components: combine strategies
+
+### Performance Considerations
+
+Compaction should achieve 50-70% token reduction with less than 5% quality degradation. Masking should achieve 60-80% reduction in masked observations. Cache optimization should achieve 70%+ hit rate for stable workloads.
+
+Monitor and iterate on optimization strategies based on measured effectiveness.
+
+## Examples
+
+**Example 1: Compaction Trigger**
+```python
+if context_tokens / context_limit > 0.8:
+    context = compact_context(context)
+```
+
+**Example 2: Observation Masking**
+```python
+if len(observation) > max_length:
+    ref_id = store_observation(observation)
+    return f"[Obs:{ref_id} elided. Key: {extract_key(observation)}]"
+```
+
+**Example 3: Cache-Friendly Ordering**
+```python
+# Stable content first
+context = [system_prompt, tool_definitions]  # Cacheable
+context += [reused_templates]  # Reusable
+context += [unique_content]  # Unique
+```
+
+## Guidelines
+
+1. Measure before optimizing—know your current state
+2. Apply compaction before masking when possible
+3. Design for cache stability with consistent prompts
+4. Partition before context becomes problematic
+5. Monitor optimization effectiveness over time
+6. Balance token savings against quality preservation
+7. Test optimization at production scale
+8. Implement graceful degradation for edge cases
+
+## Integration
+
+This skill builds on context-fundamentals and context-degradation. It connects to:
+
+- multi-agent-patterns - Partitioning as isolation
+- evaluation - Measuring optimization effectiveness
+- memory-systems - Offloading context to memory
+
+## References
+
+Internal reference:
+- [Optimization Techniques Reference](./references/optimization_techniques.md) - Detailed technical reference
+
+Related skills in this collection:
+- context-fundamentals - Context basics
+- context-degradation - Understanding when to optimize
+- evaluation - Measuring optimization
+
+External resources:
+- Research on context window limitations
+- KV-cache optimization techniques
+- Production engineering guides
+
+---
+
+## Skill Metadata
+
+**Created**: 2025-12-20
+**Last Updated**: 2025-12-20
+**Author**: Agent Skills for Context Engineering Contributors
+**Version**: 1.0.0

package/skills/cost-optimization/SKILL.md

@@ -0,0 +1,286 @@
+---
+name: cost-optimization
+description: Optimize cloud costs through resource rightsizing, tagging strategies, reserved instances, and spending analysis. Use when reducing cloud expenses, analyzing infrastructure costs, or implementing cost governance policies.
+---
+
+# Cloud Cost Optimization
+
+Strategies and patterns for optimizing cloud costs across AWS, Azure, and GCP.
+
+## Do not use this skill when
+
+- The task is unrelated to cloud cost optimization
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Purpose
+
+Implement systematic cost optimization strategies to reduce cloud spending while maintaining performance and reliability.
+
+## Use this skill when
+
+- Reduce cloud spending
+- Right-size resources
+- Implement cost governance
+- Optimize multi-cloud costs
+- Meet budget constraints
+
+## Cost Optimization Framework
+
+### 1. Visibility
+- Implement cost allocation tags
+- Use cloud cost management tools
+- Set up budget alerts
+- Create cost dashboards
+
+### 2. Right-Sizing
+- Analyze resource utilization
+- Downsize over-provisioned resources
+- Use auto-scaling
+- Remove idle resources
+
+### 3. Pricing Models
+- Use reserved capacity
+- Leverage spot/preemptible instances
+- Implement savings plans
+- Use committed use discounts
+
+### 4. Architecture Optimization
+- Use managed services
+- Implement caching
+- Optimize data transfer
+- Use lifecycle policies
+
+## AWS Cost Optimization
+
+### Reserved Instances
+```
+Savings: 30-72% vs On-Demand
+Term: 1 or 3 years
+Payment: All/Partial/No upfront
+Flexibility: Standard or Convertible
+```
+
+### Savings Plans
+```
+Compute Savings Plans: 66% savings
+EC2 Instance Savings Plans: 72% savings
+Applies to: EC2, Fargate, Lambda
+Flexible across: Instance families, regions, OS
+```
+
+### Spot Instances
+```
+Savings: Up to 90% vs On-Demand
+Best for: Batch jobs, CI/CD, stateless workloads
+Risk: 2-minute interruption notice
+Strategy: Mix with On-Demand for resilience
+```
+
+### S3 Cost Optimization
+```hcl
+resource "aws_s3_bucket_lifecycle_configuration" "example" {
+  bucket = aws_s3_bucket.example.id
+
+  rule {
+    id     = "transition-to-ia"
+    status = "Enabled"
+
+    transition {
+      days          = 30
+      storage_class = "STANDARD_IA"
+    }
+
+    transition {
+      days          = 90
+      storage_class = "GLACIER"
+    }
+
+    expiration {
+      days = 365
+    }
+  }
+}
+```
+
+## Azure Cost Optimization
+
+### Reserved VM Instances
+- 1 or 3 year terms
+- Up to 72% savings
+- Flexible sizing
+- Exchangeable
+
+### Azure Hybrid Benefit
+- Use existing Windows Server licenses
+- Up to 80% savings with RI
+- Available for Windows and SQL Server
+
+### Azure Advisor Recommendations
+- Right-size VMs
+- Delete unused resources
+- Use reserved capacity
+- Optimize storage
+
+## GCP Cost Optimization
+
+### Committed Use Discounts
+- 1 or 3 year commitment
+- Up to 57% savings
+- Applies to vCPUs and memory
+- Resource-based or spend-based
+
+### Sustained Use Discounts
+- Automatic discounts
+- Up to 30% for running instances
+- No commitment required
+- Applies to Compute Engine, GKE
+
+### Preemptible VMs
+- Up to 80% savings
+- 24-hour maximum runtime
+- Best for batch workloads
+
+## Tagging Strategy
+
+### AWS Tagging
+```hcl
+locals {
+  common_tags = {
+    Environment = "production"
+    Project     = "my-project"
+    CostCenter  = "engineering"
+    Owner       = "team@example.com"
+    ManagedBy   = "terraform"
+  }
+}
+
+resource "aws_instance" "example" {
+  ami           = "ami-12345678"
+  instance_type = "t3.medium"
+
+  tags = merge(
+    local.common_tags,
+    {
+      Name = "web-server"
+    }
+  )
+}
+```
+
+**Reference:** See `references/tagging-standards.md`
+
+## Cost Monitoring
+
+### Budget Alerts
+```hcl
+# AWS Budget
+resource "aws_budgets_budget" "monthly" {
+  name              = "monthly-budget"
+  budget_type       = "COST"
+  limit_amount      = "1000"
+  limit_unit        = "USD"
+  time_period_start = "2024-01-01_00:00"
+  time_unit         = "MONTHLY"
+
+  notification {
+    comparison_operator        = "GREATER_THAN"
+    threshold                  = 80
+    threshold_type            = "PERCENTAGE"
+    notification_type         = "ACTUAL"
+    subscriber_email_addresses = ["team@example.com"]
+  }
+}
+```
+
+### Cost Anomaly Detection
+- AWS Cost Anomaly Detection
+- Azure Cost Management alerts
+- GCP Budget alerts
+
+## Architecture Patterns
+
+### Pattern 1: Serverless First
+- Use Lambda/Functions for event-driven
+- Pay only for execution time
+- Auto-scaling included
+- No idle costs
+
+### Pattern 2: Right-Sized Databases
+```
+Development: t3.small RDS
+Staging: t3.large RDS
+Production: r6g.2xlarge RDS with read replicas
+```
+
+### Pattern 3: Multi-Tier Storage
+```
+Hot data: S3 Standard
+Warm data: S3 Standard-IA (30 days)
+Cold data: S3 Glacier (90 days)
+Archive: S3 Deep Archive (365 days)
+```
+
+### Pattern 4: Auto-Scaling
+```hcl
+resource "aws_autoscaling_policy" "scale_up" {
+  name                   = "scale-up"
+  scaling_adjustment     = 2
+  adjustment_type        = "ChangeInCapacity"
+  cooldown              = 300
+  autoscaling_group_name = aws_autoscaling_group.main.name
+}
+
+resource "aws_cloudwatch_metric_alarm" "cpu_high" {
+  alarm_name          = "cpu-high"
+  comparison_operator = "GreaterThanThreshold"
+  evaluation_periods  = "2"
+  metric_name         = "CPUUtilization"
+  namespace           = "AWS/EC2"
+  period              = "60"
+  statistic           = "Average"
+  threshold           = "80"
+  alarm_actions       = [aws_autoscaling_policy.scale_up.arn]
+}
+```
+
+## Cost Optimization Checklist
+
+- [ ] Implement cost allocation tags
+- [ ] Delete unused resources (EBS, EIPs, snapshots)
+- [ ] Right-size instances based on utilization
+- [ ] Use reserved capacity for steady workloads
+- [ ] Implement auto-scaling
+- [ ] Optimize storage classes
+- [ ] Use lifecycle policies
+- [ ] Enable cost anomaly detection
+- [ ] Set budget alerts
+- [ ] Review costs weekly
+- [ ] Use spot/preemptible instances
+- [ ] Optimize data transfer costs
+- [ ] Implement caching layers
+- [ ] Use managed services
+- [ ] Monitor and optimize continuously
+
+## Tools
+
+- **AWS:** Cost Explorer, Cost Anomaly Detection, Compute Optimizer
+- **Azure:** Cost Management, Advisor
+- **GCP:** Cost Management, Recommender
+- **Multi-cloud:** CloudHealth, Cloudability, Kubecost
+
+## Reference Files
+
+- `references/tagging-standards.md` - Tagging conventions
+- `assets/cost-analysis-template.xlsx` - Cost analysis spreadsheet
+
+## Related Skills
+
+- `terraform-module-library` - For resource provisioning
+- `multi-cloud-architecture` - For cloud selection

package/skills/cpp-pro/SKILL.md

@@ -1,97 +1,59 @@
 ---
 name: cpp-pro
-description: Use when building C++ applications requiring modern C++20/23 features, template metaprogramming, or high-performance systems. Invoke for concepts, ranges, coroutines, SIMD optimization, memory management.
-triggers:
-  - C++
-  - C++20
-  - C++23
-  - modern C++
-  - template metaprogramming
-  - systems programming
-  - performance optimization
-  - SIMD
-  - memory management
-  - CMake
-role: specialist
-scope: implementation
-output-format: code
+description: Write idiomatic C++ code with modern features, RAII, smart
+  pointers, and STL algorithms. Handles templates, move semantics, and
+  performance optimization. Use PROACTIVELY for C++ refactoring, memory safety,
+  or complex C++ patterns.
+metadata:
+  model: opus
 ---
 
-# C++ Pro
+## Use this skill when
 
-Senior C++ developer with deep expertise in modern C++20/23, systems programming, high-performance computing, and zero-overhead abstractions.
+- Working on cpp pro tasks or workflows
+- Needing guidance, best practices, or checklists for cpp pro
 
-## Role Definition
+## Do not use this skill when
 
-You are a senior C++ engineer with 15+ years of systems programming experience. You specialize in modern C++20/23, template metaprogramming, performance optimization, and building production-grade systems with emphasis on safety, efficiency, and maintainability. You follow C++ Core Guidelines and leverage cutting-edge language features.
+- The task is unrelated to cpp pro
+- You need a different domain or tool outside this scope
 
-## When to Use This Skill
+## Instructions
 
-- Building high-performance C++ applications
-- Implementing template metaprogramming solutions
-- Optimizing memory-critical systems
-- Developing concurrent and parallel algorithms
-- Creating custom allocators and memory pools
-- Systems programming and embedded development
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
 
-## Core Workflow
+You are a C++ programming expert specializing in modern C++ and high-performance software.
 
-1. **Analyze architecture** - Review build system, compiler flags, performance requirements
-2. **Design with concepts** - Create type-safe interfaces using C++20 concepts
-3. **Implement zero-cost** - Apply RAII, constexpr, and zero-overhead abstractions
-4. **Verify quality** - Run sanitizers, static analysis, and performance benchmarks
-5. **Optimize** - Profile, measure, and apply targeted optimizations
+## Focus Areas
 
-## Reference Guide
+- Modern C++ (C++11/14/17/20/23) features
+- RAII and smart pointers (unique_ptr, shared_ptr)
+- Template metaprogramming and concepts
+- Move semantics and perfect forwarding
+- STL algorithms and containers
+- Concurrency with std::thread and atomics
+- Exception safety guarantees
 
-Load detailed guidance based on context:
+## Approach
 
-| Topic | Reference | Load When |
-|-------|-----------|-----------|
-| Modern C++ Features | `references/modern-cpp.md` | C++20/23 features, concepts, ranges, coroutines |
-| Template Metaprogramming | `references/templates.md` | Variadic templates, SFINAE, type traits, CRTP |
-| Memory & Performance | `references/memory-performance.md` | Allocators, SIMD, cache optimization, move semantics |
-| Concurrency | `references/concurrency.md` | Atomics, lock-free structures, thread pools, coroutines |
-| Build & Tooling | `references/build-tooling.md` | CMake, sanitizers, static analysis, testing |
+1. Prefer stack allocation and RAII over manual memory management
+2. Use smart pointers when heap allocation is necessary
+3. Follow the Rule of Zero/Three/Five
+4. Use const correctness and constexpr where applicable
+5. Leverage STL algorithms over raw loops
+6. Profile with tools like perf and VTune
 
-## Constraints
+## Output
 
-### MUST DO
-- Follow C++ Core Guidelines
-- Use concepts for template constraints
-- Apply RAII universally
-- Use `auto` with type deduction
-- Prefer `std::unique_ptr` and `std::shared_ptr`
-- Enable all compiler warnings (-Wall -Wextra -Wpedantic)
-- Run AddressSanitizer and UndefinedBehaviorSanitizer
-- Write const-correct code
+- Modern C++ code following best practices
+- CMakeLists.txt with appropriate C++ standard
+- Header files with proper include guards or #pragma once
+- Unit tests using Google Test or Catch2
+- AddressSanitizer/ThreadSanitizer clean output
+- Performance benchmarks using Google Benchmark
+- Clear documentation of template interfaces
 
-### MUST NOT DO
-- Use raw `new`/`delete` (prefer smart pointers)
-- Ignore compiler warnings
-- Use C-style casts (use static_cast, etc.)
-- Mix exception and error code patterns inconsistently
-- Write non-const-correct code
-- Use `using namespace std` in headers
-- Ignore undefined behavior
-- Skip move semantics for expensive types
-
-## Output Templates
-
-When implementing C++ features, provide:
-1. Header file with interfaces and templates
-2. Implementation file (when needed)
-3. CMakeLists.txt updates (if applicable)
-4. Test file demonstrating usage
-5. Brief explanation of design decisions and performance characteristics
-
-## Knowledge Reference
-
-C++20/23, concepts, ranges, coroutines, modules, template metaprogramming, SFINAE, type traits, CRTP, smart pointers, custom allocators, move semantics, RAII, SIMD, atomics, lock-free programming, CMake, Conan, sanitizers, clang-tidy, cppcheck, Catch2, GoogleTest
-
-## Related Skills
-
-- **Rust Engineer** - Memory safety with different approach
-- **Performance Engineer** - Profiling and optimization
-- **Systems Architect** - Low-level system design
-- **Embedded Systems** - Resource-constrained environments
+Follow C++ Core Guidelines. Prefer compile-time errors over runtime errors.

package/skills/cqrs-implementation/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: cqrs-implementation
+description: Implement Command Query Responsibility Segregation for scalable architectures. Use when separating read and write models, optimizing query performance, or building event-sourced systems.
+---
+
+# CQRS Implementation
+
+Comprehensive guide to implementing CQRS (Command Query Responsibility Segregation) patterns.
+
+## Use this skill when
+
+- Separating read and write concerns
+- Scaling reads independently from writes
+- Building event-sourced systems
+- Optimizing complex query scenarios
+- Different read/write data models are needed
+- High-performance reporting is required
+
+## Do not use this skill when
+
+- The domain is simple and CRUD is sufficient
+- You cannot operate separate read/write models
+- Strong immediate consistency is required everywhere
+
+## Instructions
+
+- Identify read/write workloads and consistency needs.
+- Define command and query models with clear boundaries.
+- Implement read model projections and synchronization.
+- Validate performance, recovery, and failure modes.
+- If detailed patterns are required, open `resources/implementation-playbook.md`.
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed CQRS patterns and templates.