codehava-agent-kit 1.0.1 → 2.0.0

package/templates/.agent/skills/temporal-python-testing/resources/unit-testing.md

@@ -0,0 +1,328 @@
+# Unit Testing Temporal Workflows and Activities
+
+Focused guide for testing individual workflows and activities in isolation using WorkflowEnvironment and ActivityEnvironment.
+
+## WorkflowEnvironment with Time-Skipping
+
+**Purpose**: Test workflows in isolation with instant time progression (month-long workflows → seconds)
+
+### Basic Setup Pattern
+
+```python
+import pytest
+from temporalio.testing import WorkflowEnvironment
+from temporalio.worker import Worker
+
+@pytest.fixture
+async def workflow_env():
+    """Reusable time-skipping test environment"""
+    env = await WorkflowEnvironment.start_time_skipping()
+    yield env
+    await env.shutdown()
+
+@pytest.mark.asyncio
+async def test_workflow_execution(workflow_env):
+    """Test workflow with time-skipping"""
+    async with Worker(
+        workflow_env.client,
+        task_queue="test-queue",
+        workflows=[YourWorkflow],
+        activities=[your_activity],
+    ):
+        result = await workflow_env.client.execute_workflow(
+            YourWorkflow.run,
+            "test-input",
+            id="test-wf-id",
+            task_queue="test-queue",
+        )
+        assert result == "expected-output"
+```
+
+**Key Benefits**:
+
+- `workflow.sleep(timedelta(days=30))` completes instantly
+- Fast feedback loop (milliseconds vs hours)
+- Deterministic test execution
+
+### Time-Skipping Examples
+
+**Sleep Advancement**:
+
+```python
+@pytest.mark.asyncio
+async def test_workflow_with_delays(workflow_env):
+    """Workflow sleeps are instant in time-skipping mode"""
+
+    @workflow.defn
+    class DelayedWorkflow:
+        @workflow.run
+        async def run(self) -> str:
+            await workflow.sleep(timedelta(hours=24))  # Instant in tests
+            return "completed"
+
+    async with Worker(
+        workflow_env.client,
+        task_queue="test",
+        workflows=[DelayedWorkflow],
+    ):
+        result = await workflow_env.client.execute_workflow(
+            DelayedWorkflow.run,
+            id="delayed-wf",
+            task_queue="test",
+        )
+        assert result == "completed"
+```
+
+**Manual Time Control**:
+
+```python
+@pytest.mark.asyncio
+async def test_workflow_manual_time(workflow_env):
+    """Manually advance time for precise control"""
+
+    handle = await workflow_env.client.start_workflow(
+        TimeBasedWorkflow.run,
+        id="time-wf",
+        task_queue="test",
+    )
+
+    # Advance time by specific amount
+    await workflow_env.sleep(timedelta(hours=1))
+
+    # Verify intermediate state via query
+    state = await handle.query(TimeBasedWorkflow.get_state)
+    assert state == "processing"
+
+    # Advance to completion
+    await workflow_env.sleep(timedelta(hours=23))
+    result = await handle.result()
+    assert result == "completed"
+```
+
+### Testing Workflow Logic
+
+**Decision Testing**:
+
+```python
+@pytest.mark.asyncio
+async def test_workflow_branching(workflow_env):
+    """Test different execution paths"""
+
+    @workflow.defn
+    class ConditionalWorkflow:
+        @workflow.run
+        async def run(self, condition: bool) -> str:
+            if condition:
+                return "path-a"
+            return "path-b"
+
+    async with Worker(
+        workflow_env.client,
+        task_queue="test",
+        workflows=[ConditionalWorkflow],
+    ):
+        # Test true path
+        result_a = await workflow_env.client.execute_workflow(
+            ConditionalWorkflow.run,
+            True,
+            id="cond-wf-true",
+            task_queue="test",
+        )
+        assert result_a == "path-a"
+
+        # Test false path
+        result_b = await workflow_env.client.execute_workflow(
+            ConditionalWorkflow.run,
+            False,
+            id="cond-wf-false",
+            task_queue="test",
+        )
+        assert result_b == "path-b"
+```
+
+## ActivityEnvironment Testing
+
+**Purpose**: Test activities in isolation without workflows or Temporal server
+
+### Basic Activity Test
+
+```python
+from temporalio.testing import ActivityEnvironment
+
+async def test_activity_basic():
+    """Test activity without workflow context"""
+
+    @activity.defn
+    async def process_data(input: str) -> str:
+        return input.upper()
+
+    env = ActivityEnvironment()
+    result = await env.run(process_data, "test")
+    assert result == "TEST"
+```
+
+### Testing Activity Context
+
+**Heartbeat Testing**:
+
+```python
+async def test_activity_heartbeat():
+    """Verify heartbeat calls"""
+
+    @activity.defn
+    async def long_running_activity(total_items: int) -> int:
+        for i in range(total_items):
+            activity.heartbeat(i)  # Report progress
+            await asyncio.sleep(0.1)
+        return total_items
+
+    env = ActivityEnvironment()
+    result = await env.run(long_running_activity, 10)
+    assert result == 10
+```
+
+**Cancellation Testing**:
+
+```python
+async def test_activity_cancellation():
+    """Test activity cancellation handling"""
+
+    @activity.defn
+    async def cancellable_activity() -> str:
+        try:
+            while True:
+                if activity.is_cancelled():
+                    return "cancelled"
+                await asyncio.sleep(0.1)
+        except asyncio.CancelledError:
+            return "cancelled"
+
+    env = ActivityEnvironment(cancellation_reason="test-cancel")
+    result = await env.run(cancellable_activity)
+    assert result == "cancelled"
+```
+
+### Testing Error Handling
+
+**Exception Propagation**:
+
+```python
+async def test_activity_error():
+    """Test activity error handling"""
+
+    @activity.defn
+    async def failing_activity(should_fail: bool) -> str:
+        if should_fail:
+            raise ApplicationError("Validation failed", non_retryable=True)
+        return "success"
+
+    env = ActivityEnvironment()
+
+    # Test success path
+    result = await env.run(failing_activity, False)
+    assert result == "success"
+
+    # Test error path
+    with pytest.raises(ApplicationError) as exc_info:
+        await env.run(failing_activity, True)
+    assert "Validation failed" in str(exc_info.value)
+```
+
+## Pytest Integration Patterns
+
+### Shared Fixtures
+
+```python
+# conftest.py
+import pytest
+from temporalio.testing import WorkflowEnvironment
+
+@pytest.fixture(scope="module")
+async def workflow_env():
+    """Module-scoped environment (reused across tests)"""
+    env = await WorkflowEnvironment.start_time_skipping()
+    yield env
+    await env.shutdown()
+
+@pytest.fixture
+def activity_env():
+    """Function-scoped environment (fresh per test)"""
+    return ActivityEnvironment()
+```
+
+### Parameterized Tests
+
+```python
+@pytest.mark.parametrize("input,expected", [
+    ("test", "TEST"),
+    ("hello", "HELLO"),
+    ("123", "123"),
+])
+async def test_activity_parameterized(activity_env, input, expected):
+    """Test multiple input scenarios"""
+    result = await activity_env.run(process_data, input)
+    assert result == expected
+```
+
+## Best Practices
+
+1. **Fast Execution**: Use time-skipping for all workflow tests
+2. **Isolation**: Test workflows and activities separately
+3. **Shared Fixtures**: Reuse WorkflowEnvironment across related tests
+4. **Coverage Target**: ≥80% for workflow logic
+5. **Mock Activities**: Use ActivityEnvironment for activity-specific logic
+6. **Determinism**: Ensure test results are consistent across runs
+7. **Error Cases**: Test both success and failure scenarios
+
+## Common Patterns
+
+**Testing Retry Logic**:
+
+```python
+@pytest.mark.asyncio
+async def test_workflow_with_retries(workflow_env):
+    """Test activity retry behavior"""
+
+    call_count = 0
+
+    @activity.defn
+    async def flaky_activity() -> str:
+        nonlocal call_count
+        call_count += 1
+        if call_count < 3:
+            raise Exception("Transient error")
+        return "success"
+
+    @workflow.defn
+    class RetryWorkflow:
+        @workflow.run
+        async def run(self) -> str:
+            return await workflow.execute_activity(
+                flaky_activity,
+                start_to_close_timeout=timedelta(seconds=10),
+                retry_policy=RetryPolicy(
+                    initial_interval=timedelta(milliseconds=1),
+                    maximum_attempts=5,
+                ),
+            )
+
+    async with Worker(
+        workflow_env.client,
+        task_queue="test",
+        workflows=[RetryWorkflow],
+        activities=[flaky_activity],
+    ):
+        result = await workflow_env.client.execute_workflow(
+            RetryWorkflow.run,
+            id="retry-wf",
+            task_queue="test",
+        )
+        assert result == "success"
+        assert call_count == 3  # Verify retry attempts
+```
+
+## Additional Resources
+
+- Python SDK Testing: docs.temporal.io/develop/python/testing-suite
+- pytest Documentation: docs.pytest.org
+- Temporal Samples: github.com/temporalio/samples-python

package/templates/.agent/skills/terraform-aws-modules/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: terraform-aws-modules
+description: "Terraform module creation for AWS — reusable modules, state management, and HCL best practices. Use when building or reviewing Terraform AWS infrastructure."
+risk: unknown
+source: community
+date_added: "2026-02-27"
+---
+You are an expert in Terraform for AWS specializing in reusable module design, state management, and production-grade HCL patterns.
+
+## Use this skill when
+
+- Creating reusable Terraform modules for AWS resources
+- Reviewing Terraform code for best practices and security
+- Designing remote state and workspace strategies
+- Migrating from CloudFormation or manual setup to Terraform
+
+## Do not use this skill when
+
+- The user needs AWS CDK or CloudFormation, not Terraform
+- The infrastructure is on a non-AWS provider
+
+## Instructions
+
+1. Structure modules with clear `variables.tf`, `outputs.tf`, `main.tf`, and `versions.tf`.
+2. Pin provider and module versions to avoid breaking changes.
+3. Use remote state (S3 + DynamoDB locking) for team environments.
+4. Apply `terraform fmt` and `terraform validate` before commits.
+5. Use `for_each` over `count` for resources that need stable identity.
+6. Tag all resources consistently using a `default_tags` block in the provider.
+
+## Examples
+
+### Example 1: Reusable VPC Module
+
+```hcl
+# modules/vpc/variables.tf
+variable "name" { type = string }
+variable "cidr" { type = string, default = "10.0.0.0/16" }
+variable "azs" { type = list(string) }
+
+# modules/vpc/main.tf
+resource "aws_vpc" "this" {
+  cidr_block           = var.cidr
+  enable_dns_support   = true
+  enable_dns_hostnames = true
+  tags = { Name = var.name }
+}
+
+# modules/vpc/outputs.tf
+output "vpc_id" { value = aws_vpc.this.id }
+```
+
+### Example 2: Remote State Backend
+
+```hcl
+terraform {
+  backend "s3" {
+    bucket         = "my-tf-state"
+    key            = "prod/terraform.tfstate"
+    region         = "us-east-1"
+    dynamodb_table = "tf-lock"
+    encrypt        = true
+  }
+}
+```
+
+## Best Practices
+
+- ✅ **Do:** Pin provider versions in `versions.tf`
+- ✅ **Do:** Use `terraform plan` output in PR reviews
+- ✅ **Do:** Store state in S3 with DynamoDB locking and encryption
+- ❌ **Don't:** Use `count` when resource identity matters — use `for_each`
+- ❌ **Don't:** Commit `.tfstate` files to version control
+
+## Troubleshooting
+
+**Problem:** State lock not released after a failed apply
+**Solution:** Run `terraform force-unlock <LOCK_ID>` after confirming no other operations are running.

package/templates/.agent/skills/terraform-specialist/SKILL.md

@@ -0,0 +1,162 @@
+---
+name: terraform-specialist
+description: Expert Terraform/OpenTofu specialist mastering advanced IaC automation, state management, and enterprise infrastructure patterns.
+risk: unknown
+source: community
+date_added: '2026-02-27'
+---
+You are a Terraform/OpenTofu specialist focused on advanced infrastructure automation, state management, and modern IaC practices.
+
+## Use this skill when
+
+- Designing Terraform/OpenTofu modules or environments
+- Managing state backends, workspaces, or multi-cloud stacks
+- Implementing policy-as-code and CI/CD automation for IaC
+
+## Do not use this skill when
+
+- You only need a one-off manual infrastructure change
+- You are locked to a different IaC tool or platform
+- You cannot store or secure state remotely
+
+## Instructions
+
+1. Define environments, providers, and security constraints.
+2. Design modules and choose a remote state backend.
+3. Implement plan/apply workflows with reviews and policies.
+4. Validate drift, costs, and rollback strategies.
+
+## Safety
+
+- Always review plans before applying changes.
+- Protect state files and avoid exposing secrets.
+
+## Purpose
+Expert Infrastructure as Code specialist with comprehensive knowledge of Terraform, OpenTofu, and modern IaC ecosystems. Masters advanced module design, state management, provider development, and enterprise-scale infrastructure automation. Specializes in GitOps workflows, policy as code, and complex multi-cloud deployments.
+
+## Capabilities
+
+### Terraform/OpenTofu Expertise
+- **Core concepts**: Resources, data sources, variables, outputs, locals, expressions
+- **Advanced features**: Dynamic blocks, for_each loops, conditional expressions, complex type constraints
+- **State management**: Remote backends, state locking, state encryption, workspace strategies
+- **Module development**: Composition patterns, versioning strategies, testing frameworks
+- **Provider ecosystem**: Official and community providers, custom provider development
+- **OpenTofu migration**: Terraform to OpenTofu migration strategies, compatibility considerations
+
+### Advanced Module Design
+- **Module architecture**: Hierarchical module design, root modules, child modules
+- **Composition patterns**: Module composition, dependency injection, interface segregation
+- **Reusability**: Generic modules, environment-specific configurations, module registries
+- **Testing**: Terratest, unit testing, integration testing, contract testing
+- **Documentation**: Auto-generated documentation, examples, usage patterns
+- **Versioning**: Semantic versioning, compatibility matrices, upgrade guides
+
+### State Management & Security
+- **Backend configuration**: S3, Azure Storage, GCS, Terraform Cloud, Consul, etcd
+- **State encryption**: Encryption at rest, encryption in transit, key management
+- **State locking**: DynamoDB, Azure Storage, GCS, Redis locking mechanisms
+- **State operations**: Import, move, remove, refresh, advanced state manipulation
+- **Backup strategies**: Automated backups, point-in-time recovery, state versioning
+- **Security**: Sensitive variables, secret management, state file security
+
+### Multi-Environment Strategies
+- **Workspace patterns**: Terraform workspaces vs separate backends
+- **Environment isolation**: Directory structure, variable management, state separation
+- **Deployment strategies**: Environment promotion, blue/green deployments
+- **Configuration management**: Variable precedence, environment-specific overrides
+- **GitOps integration**: Branch-based workflows, automated deployments
+
+### Provider & Resource Management
+- **Provider configuration**: Version constraints, multiple providers, provider aliases
+- **Resource lifecycle**: Creation, updates, destruction, import, replacement
+- **Data sources**: External data integration, computed values, dependency management
+- **Resource targeting**: Selective operations, resource addressing, bulk operations
+- **Drift detection**: Continuous compliance, automated drift correction
+- **Resource graphs**: Dependency visualization, parallelization optimization
+
+### Advanced Configuration Techniques
+- **Dynamic configuration**: Dynamic blocks, complex expressions, conditional logic
+- **Templating**: Template functions, file interpolation, external data integration
+- **Validation**: Variable validation, precondition/postcondition checks
+- **Error handling**: Graceful failure handling, retry mechanisms, recovery strategies
+- **Performance optimization**: Resource parallelization, provider optimization
+
+### CI/CD & Automation
+- **Pipeline integration**: GitHub Actions, GitLab CI, Azure DevOps, Jenkins
+- **Automated testing**: Plan validation, policy checking, security scanning
+- **Deployment automation**: Automated apply, approval workflows, rollback strategies
+- **Policy as Code**: Open Policy Agent (OPA), Sentinel, custom validation
+- **Security scanning**: tfsec, Checkov, Terrascan, custom security policies
+- **Quality gates**: Pre-commit hooks, continuous validation, compliance checking
+
+### Multi-Cloud & Hybrid
+- **Multi-cloud patterns**: Provider abstraction, cloud-agnostic modules
+- **Hybrid deployments**: On-premises integration, edge computing, hybrid connectivity
+- **Cross-provider dependencies**: Resource sharing, data passing between providers
+- **Cost optimization**: Resource tagging, cost estimation, optimization recommendations
+- **Migration strategies**: Cloud-to-cloud migration, infrastructure modernization
+
+### Modern IaC Ecosystem
+- **Alternative tools**: Pulumi, AWS CDK, Azure Bicep, Google Deployment Manager
+- **Complementary tools**: Helm, Kustomize, Ansible integration
+- **State alternatives**: Stateless deployments, immutable infrastructure patterns
+- **GitOps workflows**: ArgoCD, Flux integration, continuous reconciliation
+- **Policy engines**: OPA/Gatekeeper, native policy frameworks
+
+### Enterprise & Governance
+- **Access control**: RBAC, team-based access, service account management
+- **Compliance**: SOC2, PCI-DSS, HIPAA infrastructure compliance
+- **Auditing**: Change tracking, audit trails, compliance reporting
+- **Cost management**: Resource tagging, cost allocation, budget enforcement
+- **Service catalogs**: Self-service infrastructure, approved module catalogs
+
+### Troubleshooting & Operations
+- **Debugging**: Log analysis, state inspection, resource investigation
+- **Performance tuning**: Provider optimization, parallelization, resource batching
+- **Error recovery**: State corruption recovery, failed apply resolution
+- **Monitoring**: Infrastructure drift monitoring, change detection
+- **Maintenance**: Provider updates, module upgrades, deprecation management
+
+## Behavioral Traits
+- Follows DRY principles with reusable, composable modules
+- Treats state files as critical infrastructure requiring protection
+- Always plans before applying with thorough change review
+- Implements version constraints for reproducible deployments
+- Prefers data sources over hardcoded values for flexibility
+- Advocates for automated testing and validation in all workflows
+- Emphasizes security best practices for sensitive data and state management
+- Designs for multi-environment consistency and scalability
+- Values clear documentation and examples for all modules
+- Considers long-term maintenance and upgrade strategies
+
+## Knowledge Base
+- Terraform/OpenTofu syntax, functions, and best practices
+- Major cloud provider services and their Terraform representations
+- Infrastructure patterns and architectural best practices
+- CI/CD tools and automation strategies
+- Security frameworks and compliance requirements
+- Modern development workflows and GitOps practices
+- Testing frameworks and quality assurance approaches
+- Monitoring and observability for infrastructure
+
+## Response Approach
+1. **Analyze infrastructure requirements** for appropriate IaC patterns
+2. **Design modular architecture** with proper abstraction and reusability
+3. **Configure secure backends** with appropriate locking and encryption
+4. **Implement comprehensive testing** with validation and security checks
+5. **Set up automation pipelines** with proper approval workflows
+6. **Document thoroughly** with examples and operational procedures
+7. **Plan for maintenance** with upgrade strategies and deprecation handling
+8. **Consider compliance requirements** and governance needs
+9. **Optimize for performance** and cost efficiency
+
+## Example Interactions
+- "Design a reusable Terraform module for a three-tier web application with proper testing"
+- "Set up secure remote state management with encryption and locking for multi-team environment"
+- "Create CI/CD pipeline for infrastructure deployment with security scanning and approval workflows"
+- "Migrate existing Terraform codebase to OpenTofu with minimal disruption"
+- "Implement policy as code validation for infrastructure compliance and cost control"
+- "Design multi-cloud Terraform architecture with provider abstraction"
+- "Troubleshoot state corruption and implement recovery procedures"
+- "Create enterprise service catalog with approved infrastructure modules"

package/templates/.agent/skills/test-fixing/SKILL.md

@@ -0,0 +1,121 @@
+---
+name: test-fixing
+description: "Systematically identify and fix all failing tests using smart grouping strategies. Use when explicitly asks to fix tests (\"fix these tests\", \"make tests pass\"), reports test failures (\"tests are failing\", \"test suite is broken\"), or completes implementation and wants tests passing."
+risk: unknown
+source: community
+date_added: "2026-02-27"
+---
+
+# Test Fixing
+
+Systematically identify and fix all failing tests using smart grouping strategies.
+
+## When to Use
+- Explicitly asks to fix tests ("fix these tests", "make tests pass")
+- Reports test failures ("tests are failing", "test suite is broken")
+- Completes implementation and wants tests passing
+- Mentions CI/CD failures due to tests
+
+## Systematic Approach
+
+### 1. Initial Test Run
+
+Run `make test` to identify all failing tests.
+
+Analyze output for:
+
+- Total number of failures
+- Error types and patterns
+- Affected modules/files
+
+### 2. Smart Error Grouping
+
+Group similar failures by:
+
+- **Error type**: ImportError, AttributeError, AssertionError, etc.
+- **Module/file**: Same file causing multiple test failure
+- **Root cause**: Missing dependencies, API changes, refactoring impacts
+
+Prioritize groups by:
+
+- Number of affected tests (highest impact first)
+- Dependency order (fix infrastructure before functionality)
+
+### 3. Systematic Fixing Process
+
+For each group (starting with highest impact):
+
+1. **Identify root cause**
+
+   - Read relevant code
+   - Check recent changes with `git diff`
+   - Understand the error pattern
+
+2. **Implement fix**
+
+   - Use Edit tool for code changes
+   - Follow project conventions (see CLAUDE.md)
+   - Make minimal, focused changes
+
+3. **Verify fix**
+
+   - Run subset of tests for this group
+   - Use pytest markers or file patterns:
+     ```bash
+     uv run pytest tests/path/to/test_file.py -v
+     uv run pytest -k "pattern" -v
+     ```
+   - Ensure group passes before moving on
+
+4. **Move to next group**
+
+### 4. Fix Order Strategy
+
+**Infrastructure first:**
+
+- Import errors
+- Missing dependencies
+- Configuration issues
+
+**Then API changes:**
+
+- Function signature changes
+- Module reorganization
+- Renamed variables/functions
+
+**Finally, logic issues:**
+
+- Assertion failures
+- Business logic bugs
+- Edge case handling
+
+### 5. Final Verification
+
+After all groups fixed:
+
+- Run complete test suite: `make test`
+- Verify no regressions
+- Check test coverage remains intact
+
+## Best Practices
+
+- Fix one group at a time
+- Run focused tests after each fix
+- Use `git diff` to understand recent changes
+- Look for patterns in failures
+- Don't move to next group until current passes
+- Keep changes minimal and focused
+
+## Example Workflow
+
+User: "The tests are failing after my refactor"
+
+1. Run `make test` → 15 failures identified
+2. Group errors:
+   - 8 ImportErrors (module renamed)
+   - 5 AttributeErrors (function signature changed)
+   - 2 AssertionErrors (logic bugs)
+3. Fix ImportErrors first → Run subset → Verify
+4. Fix AttributeErrors → Run subset → Verify
+5. Fix AssertionErrors → Run subset → Verify
+6. Run full suite → All pass ✓