@forwardimpact/pathway 0.4.0 → 0.6.0

package/examples/agents/.claude/skills/architecture-design/SKILL.md

@@ -1,130 +0,0 @@
----
-name: architecture-design
-description: |
-  Guide for designing software systems and making architectural decisions.
-  Use when asked to design a system, evaluate architecture options, or
-  make structural decisions about code organization.
----
-
-# Architecture & Design
-
-## Stage Guidance
-
-### Plan Stage
-
-**Focus:** Understand requirements and identify key architectural decisions.
-Document trade-offs and design rationale.
-
-**Activities:**
-
-- Clarify functional and non-functional requirements
-- Identify constraints (existing systems, team skills, timeline)
-- Document key decisions and trade-offs
-- Design for anticipated change
-
-**Ready for Code when:**
-
-- [ ] Requirements are clearly understood
-- [ ] Key decisions are documented with rationale
-- [ ] Trade-offs are explicit
-- [ ] Failure modes are considered
-
-### Code Stage
-
-**Focus:** Implement architecture with clear boundaries and interfaces. Ensure
-components can evolve independently.
-
-**Activities:**
-
-- Define clear interfaces between components
-- Implement with appropriate patterns
-- Document design decisions in code
-- Test architectural boundaries
-
-**Ready for Review when:**
-
-- [ ] Dependencies are minimal and explicit
-- [ ] Interfaces are well-defined
-- [ ] Design patterns are documented
-- [ ] Architecture tests pass
-
-### Review Stage
-
-**Focus:** Validate architecture meets requirements and is maintainable. Ensure
-scalability and security are addressed.
-
-**Activities:**
-
-- Verify architecture meets requirements
-- Review for scalability concerns
-- Check security implications
-- Validate documentation completeness
-
-**Ready for Complete when:**
-
-- [ ] Scalability requirements are addressed
-- [ ] Security implications are reviewed
-- [ ] Architecture is documented
-- [ ] Design is maintainable
-
-## Reference
-
-## Design Process
-
-### 1. Understand Requirements
-
-Before designing, clarify:
-
-- What problem are we solving?
-- What are the non-functional requirements (scale, latency, availability)?
-- What are the constraints (existing systems, team skills, timeline)?
-- What will change over time?
-
-### 2. Identify Key Decisions
-
-Architecture is the set of decisions that are hard to change:
-
-- Data storage and schema design
-- Service boundaries and communication patterns
-- Synchronous vs asynchronous processing
-- Stateful vs stateless components
-
-### 3. Evaluate Trade-offs
-
-Every architectural choice has trade-offs:
-
-- Consistency vs availability
-- Simplicity vs flexibility
-- Performance vs maintainability
-- Build vs buy
-
-Document trade-offs explicitly.
-
-### 4. Design for Change
-
-Good architecture accommodates change:
-
-- Separate what changes from what stays the same
-- Define clear interfaces between components
-- Prefer composition over inheritance
-- Make dependencies explicit
-
-## Common Patterns
-
-### Service Architecture
-
-- Microservices: Independent deployment, clear boundaries
-- Monolith: Simpler deployment, easier refactoring
-- Modular monolith: Boundaries within single deployment
-
-### Data Patterns
-
-- Event sourcing: Full audit trail, complex queries
-- CQRS: Separate read and write models
-- Repository pattern: Abstract data access
-
-### Communication Patterns
-
-- REST: Synchronous, request-response
-- Event-driven: Asynchronous, loose coupling
-- gRPC: Efficient, strongly typed

package/examples/agents/.claude/skills/cloud-platforms/SKILL.md

@@ -1,131 +0,0 @@
----
-name: cloud-platforms
-description: |
-  Guide for working with cloud infrastructure and services. Use when
-  deploying to cloud, selecting cloud services, configuring infrastructure,
-  or solving cloud-specific challenges.
----
-
-# Cloud Platforms
-
-## Stage Guidance
-
-### Plan Stage
-
-**Focus:** Select appropriate cloud services and design for availability,
-security, and cost efficiency.
-
-**Activities:**
-
-- Identify service requirements
-- Select appropriate cloud services
-- Plan for high availability
-- Consider security and cost
-
-**Ready for Code when:**
-
-- [ ] Service selection matches requirements
-- [ ] Availability approach planned
-- [ ] Security model defined
-- [ ] Cost controls considered
-
-### Code Stage
-
-**Focus:** Implement cloud infrastructure with security best practices. Use
-infrastructure as code for reproducibility.
-
-**Activities:**
-
-- Define infrastructure as code
-- Configure security groups and IAM
-- Set up monitoring and alerting
-- Implement deployment automation
-
-**Ready for Review when:**
-
-- [ ] Multi-AZ deployment for availability
-- [ ] Security groups properly configured
-- [ ] IAM follows least privilege
-- [ ] Data encrypted at rest and in transit
-- [ ] Infrastructure defined as code
-
-### Review Stage
-
-**Focus:** Validate security, availability, and operational readiness. Ensure
-cost controls are in place.
-
-**Activities:**
-
-- Verify security configuration
-- Test availability and failover
-- Review cost projections
-- Validate monitoring coverage
-
-**Ready for Complete when:**
-
-- [ ] Security review completed
-- [ ] Monitoring and alerting in place
-- [ ] Cost controls established
-- [ ] Operational runbooks exist
-
-## Reference
-
-## Service Categories
-
-### Compute
-
-- **VMs/EC2**: Full control, any workload
-- **Containers/ECS/GKE**: Portable, scalable applications
-- **Serverless/Lambda**: Event-driven, pay-per-use
-- **Kubernetes**: Container orchestration at scale
-
-### Storage
-
-- **Object Storage (S3/GCS)**: Unstructured data, backups, static assets
-- **Block Storage (EBS)**: VM disks, databases
-- **File Storage (EFS)**: Shared file systems
-- **Archive (Glacier)**: Long-term, infrequent access
-
-### Databases
-
-- **Managed SQL (RDS/Cloud SQL)**: Relational, ACID transactions
-- **NoSQL (DynamoDB/Firestore)**: Flexible schema, high scale
-- **Cache (ElastiCache/Memorystore)**: Low-latency data access
-- **Data Warehouse (Redshift/BigQuery)**: Analytics at scale
-
-### Messaging
-
-- **Queues (SQS/Cloud Tasks)**: Decoupled processing
-- **Pub/Sub (SNS/Cloud Pub/Sub)**: Event distribution
-- **Streaming (Kinesis/Dataflow)**: Real-time data processing
-
-## Cloud-Native Design
-
-### Principles
-
-- Design for failure (everything fails eventually)
-- Use managed services when possible
-- Automate everything (infrastructure as code)
-- Monitor and alert on all services
-
-### High Availability
-
-- Deploy across multiple availability zones
-- Use load balancers for traffic distribution
-- Implement health checks and auto-healing
-- Design for graceful degradation
-
-### Security
-
-- Principle of least privilege for IAM
-- Encrypt data at rest and in transit
-- Use security groups and network policies
-- Rotate credentials regularly
-
-## Cost Optimization
-
-- Right-size instances based on actual usage
-- Use reserved instances for predictable workloads
-- Leverage spot/preemptible instances for fault-tolerant work
-- Set up billing alerts and budgets
-- Delete unused resources

package/examples/agents/.claude/skills/code-quality-review/SKILL.md

@@ -1,108 +0,0 @@
----
-name: code-quality-review
-description: |
-  Guide for reviewing code quality, identifying issues, and suggesting
-  improvements. Use when asked to review code, check for best practices,
-  or conduct code reviews.
----
-
-# Code Quality & Review
-
-## Stage Guidance
-
-### Plan Stage
-
-**Focus:** Understand code review scope and establish review criteria. Consider
-what quality standards apply.
-
-**Activities:**
-
-- Identify code review scope
-- Understand applicable standards
-- Plan review approach
-- Consider risk level
-
-**Ready for Code when:**
-
-- [ ] Review scope is clear
-- [ ] Standards are understood
-- [ ] Review approach is planned
-- [ ] Risk level is assessed
-
-### Code Stage
-
-**Focus:** Write clean, maintainable, tested code. Follow project conventions
-and ensure adequate coverage.
-
-**Activities:**
-
-- Write readable, well-structured code
-- Add appropriate tests
-- Follow project conventions
-- Document non-obvious logic
-
-**Ready for Review when:**
-
-- [ ] Code compiles and passes all tests
-- [ ] Changes are covered by tests
-- [ ] Code follows project conventions
-- [ ] No unnecessary complexity
-
-### Review Stage
-
-**Focus:** Verify correctness, maintainability, and adherence to standards.
-Ensure no code is shipped that isn't understood.
-
-**Activities:**
-
-- Verify code does what it claims
-- Check test coverage
-- Review for maintainability
-- Confirm style compliance
-
-**Ready for Complete when:**
-
-- [ ] No obvious security vulnerabilities
-- [ ] Error handling is appropriate
-- [ ] Documentation updated if needed
-- [ ] No code you don't fully understand
-
-## Reference
-
-## Review Process
-
-### 1. Correctness First
-
-Before anything else, verify the code does what it claims:
-
-- Does it implement the intended behavior?
-- Are there logic errors or off-by-one bugs?
-- Does it handle all specified requirements?
-- Are error conditions handled appropriately?
-
-### 2. Test Coverage
-
-Check that changes are properly tested:
-
-- Unit tests for new functionality
-- Edge cases and error conditions
-- Integration tests where appropriate
-- Tests are readable and maintainable
-
-### 3. Maintainability
-
-Evaluate long-term code health:
-
-- Clear naming (variables, functions, classes)
-- Appropriate abstraction levels
-- No unnecessary duplication (DRY)
-- Single responsibility principle applied
-
-### 4. Code Style
-
-Verify consistency with project standards:
-
-- Follows project coding conventions
-- Consistent formatting and indentation
-- Appropriate comments for non-obvious logic
-- Documentation updated if needed

package/examples/agents/.claude/skills/devops-cicd/SKILL.md

@@ -1,142 +0,0 @@
----
-name: devops-cicd
-description: |
-  Guide for building CI/CD pipelines, managing infrastructure as code, and
-  implementing deployment best practices. Use when setting up pipelines,
-  containerizing applications, or configuring infrastructure.
----
-
-# DevOps & CI/CD
-
-## Stage Guidance
-
-### Plan Stage
-
-**Focus:** Plan CI/CD pipeline architecture and infrastructure requirements.
-Consider deployment strategies and monitoring needs.
-
-**Activities:**
-
-- Define pipeline stages (build, test, deploy)
-- Identify infrastructure requirements
-- Plan deployment strategy (rolling, blue-green, canary)
-- Consider monitoring and alerting needs
-- Plan secret management approach
-
-**Ready for Code when:**
-
-- [ ] Pipeline architecture is documented
-- [ ] Deployment strategy is chosen and justified
-- [ ] Infrastructure requirements are identified
-- [ ] Monitoring approach is defined
-
-### Code Stage
-
-**Focus:** Implement CI/CD pipelines and infrastructure as code. Follow best
-practices for containerization and deployment automation.
-
-**Activities:**
-
-- Configure CI/CD pipeline stages
-- Implement infrastructure as code (Terraform, CloudFormation)
-- Create Dockerfiles with security best practices
-- Set up monitoring and alerting
-- Configure secret management
-- Implement deployment automation
-
-**Ready for Review when:**
-
-- [ ] Pipeline runs on every commit
-- [ ] Tests run before deployment
-- [ ] Deployments are automated
-- [ ] Infrastructure is version controlled
-- [ ] Secrets are managed securely
-- [ ] Monitoring is in place
-
-### Review Stage
-
-**Focus:** Verify pipeline reliability, security, and operational readiness.
-Ensure rollback procedures work and documentation is complete.
-
-**Activities:**
-
-- Verify pipeline runs successfully end-to-end
-- Test rollback procedures
-- Review security configurations
-- Validate monitoring and alerts
-- Check documentation completeness
-
-**Ready for Complete when:**
-
-- [ ] Pipeline is tested and reliable
-- [ ] Rollback procedure is documented and tested
-- [ ] Alerts are configured and tested
-- [ ] Runbooks exist for common issues
-
-## Reference
-
-## CI/CD Pipeline Stages
-
-### Build
-
-- Install dependencies
-- Compile/transpile code
-- Generate artifacts
-- Cache dependencies for speed
-
-### Test
-
-- Run unit tests
-- Run integration tests
-- Static analysis and linting
-- Security scanning
-
-### Deploy
-
-- Deploy to staging environment
-- Run smoke tests
-- Deploy to production
-- Verify deployment health
-
-## Infrastructure as Code
-
-### Terraform
-
-```hcl
-# Define resources declaratively
-resource "aws_instance" "example" {
-  ami           = "ami-0c55b159cbfafe1f0"
-  instance_type = "t2.micro"
-}
-```
-
-### Docker
-
-```dockerfile
-FROM node:18-alpine
-WORKDIR /app
-COPY package*.json ./
-RUN npm ci --only=production
-COPY . .
-CMD ["node", "server.js"]
-```
-
-## Deployment Strategies
-
-### Rolling Deployment
-
-- Gradual replacement of instances
-- Zero downtime
-- Easy rollback
-
-### Blue-Green Deployment
-
-- Two identical environments
-- Switch traffic atomically
-- Fast rollback
-
-### Canary Deployment
-
-- Route small percentage to new version
-- Monitor for issues
-- Gradually increase traffic

package/examples/agents/.claude/skills/full-stack-development/SKILL.md

@@ -1,134 +0,0 @@
----
-name: full-stack-development
-description: |
-  Guide for building complete solutions across the full technology stack.
-  Use when asked to implement features spanning frontend, backend, database,
-  and infrastructure layers.
----
-
-# Full-Stack Development
-
-## Stage Guidance
-
-### Plan Stage
-
-**Focus:** Design the full-stack solution architecture. Define API contracts and
-plan layer interactions.
-
-**Activities:**
-
-- Define the API contract first
-- Plan frontend and backend responsibilities
-- Design database schema
-- Plan infrastructure requirements
-
-**Ready for Code when:**
-
-- [ ] API contract is defined
-- [ ] Layer responsibilities are clear
-- [ ] Database schema is planned
-- [ ] Infrastructure approach is decided
-
-### Code Stage
-
-**Focus:** Build vertically—complete one feature end-to-end before starting
-another. Validates assumptions early.
-
-**Activities:**
-
-- Implement API endpoints
-- Build frontend integration
-- Create database schema and queries
-- Configure infrastructure as needed
-- Test across layers
-
-**Ready for Review when:**
-
-- [ ] Frontend connects to backend correctly
-- [ ] Database schema supports the feature
-- [ ] Error handling spans all layers
-- [ ] Feature works end-to-end
-- [ ] Deployment is automated
-
-### Review Stage
-
-**Focus:** Verify integration across layers and ensure deployment readiness.
-
-**Activities:**
-
-- Test integration across all layers
-- Verify error handling end-to-end
-- Check deployment configuration
-- Review documentation
-
-**Ready for Complete when:**
-
-- [ ] Integration tests pass
-- [ ] Deployment verified
-- [ ] Documentation is complete
-- [ ] Feature is production-ready
-
-## Reference
-
-## Technology Stack
-
-### Primary Languages
-
-- **JavaScript/TypeScript**: Frontend and Node.js backend
-- **Python**: Backend APIs and data processing
-
-### Infrastructure
-
-- **Terraform**: Cloud infrastructure as code
-- **CloudFormation**: AWS-specific infrastructure
-- **Docker**: Containerization
-
-## Layer Responsibilities
-
-### Frontend
-
-- User interface and experience
-- Client-side validation
-- API integration
-- State management
-
-### Backend API
-
-- Business logic
-- Data validation
-- Authentication/authorization
-- External service integration
-
-### Database
-
-- Data persistence
-- Query optimization
-- Schema migrations
-- Data integrity
-
-### Infrastructure
-
-- Deployment pipelines
-- Environment configuration
-- Scaling and reliability
-- Monitoring and logging
-
-## Development Process
-
-### 1. Start with the Interface
-
-- Define the API contract first
-- Frontend and backend can work in parallel
-- Clear interface = fewer integration issues
-
-### 2. Build Vertically
-
-- Complete one feature end-to-end before starting another
-- Validates assumptions early
-- Delivers demonstrable progress
-
-### 3. Test Across Layers
-
-- Unit tests per layer
-- Integration tests across layers
-- End-to-end tests for critical paths