@ruaruababa/vibe-kit 1.0.0

package/skills/multi-platform-apps-multi-platform/SKILL.md

@@ -0,0 +1,203 @@
+---
+name: multi-platform-apps-multi-platform
+description: "Build and deploy the same feature consistently across web, mobile, and desktop platforms using API-first architecture and parallel implementation strategies."
+---
+
+# Multi-Platform Feature Development Workflow
+
+Build and deploy the same feature consistently across web, mobile, and desktop platforms using API-first architecture and parallel implementation strategies.
+
+[Extended thinking: This workflow orchestrates multiple specialized agents to ensure feature parity across platforms while maintaining platform-specific optimizations. The coordination strategy emphasizes shared contracts and parallel development with regular synchronization points. By establishing API contracts and data models upfront, teams can work independently while ensuring consistency. The workflow benefits include faster time-to-market, reduced integration issues, and maintainable cross-platform codebases.]
+
+## Use this skill when
+
+- Working on multi-platform feature development workflow tasks or workflows
+- Needing guidance, best practices, or checklists for multi-platform feature development workflow
+
+## Do not use this skill when
+
+- The task is unrelated to multi-platform feature development workflow
+- 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`.
+
+## Phase 1: Architecture and API Design (Sequential)
+
+### 1. Define Feature Requirements and API Contracts
+- Use Task tool with subagent_type="backend-architect"
+- Prompt: "Design the API contract for feature: $ARGUMENTS. Create OpenAPI 3.1 specification with:
+  - RESTful endpoints with proper HTTP methods and status codes
+  - GraphQL schema if applicable for complex data queries
+  - WebSocket events for real-time features
+  - Request/response schemas with validation rules
+  - Authentication and authorization requirements
+  - Rate limiting and caching strategies
+  - Error response formats and codes
+  Define shared data models that all platforms will consume."
+- Expected output: Complete API specification, data models, and integration guidelines
+
+### 2. Design System and UI/UX Consistency
+- Use Task tool with subagent_type="ui-ux-designer"
+- Prompt: "Create cross-platform design system for feature using API spec: [previous output]. Include:
+  - Component specifications for each platform (Material Design, iOS HIG, Fluent)
+  - Responsive layouts for web (mobile-first approach)
+  - Native patterns for iOS (SwiftUI) and Android (Material You)
+  - Desktop-specific considerations (keyboard shortcuts, window management)
+  - Accessibility requirements (WCAG 2.2 Level AA)
+  - Dark/light theme specifications
+  - Animation and transition guidelines"
+- Context from previous: API endpoints, data structures, authentication flows
+- Expected output: Design system documentation, component library specs, platform guidelines
+
+### 3. Shared Business Logic Architecture
+- Use Task tool with subagent_type="comprehensive-review::architect-review"
+- Prompt: "Design shared business logic architecture for cross-platform feature. Define:
+  - Core domain models and entities (platform-agnostic)
+  - Business rules and validation logic
+  - State management patterns (MVI/Redux/BLoC)
+  - Caching and offline strategies
+  - Error handling and retry policies
+  - Platform-specific adapter patterns
+  Consider Kotlin Multiplatform for mobile or TypeScript for web/desktop sharing."
+- Context from previous: API contracts, data models, UI requirements
+- Expected output: Shared code architecture, platform abstraction layers, implementation guide
+
+## Phase 2: Parallel Platform Implementation
+
+### 4a. Web Implementation (React/Next.js)
+- Use Task tool with subagent_type="frontend-developer"
+- Prompt: "Implement web version of feature using:
+  - React 18+ with Next.js 14+ App Router
+  - TypeScript for type safety
+  - TanStack Query for API integration: [API spec]
+  - Zustand/Redux Toolkit for state management
+  - Tailwind CSS with design system: [design specs]
+  - Progressive Web App capabilities
+  - SSR/SSG optimization where appropriate
+  - Web vitals optimization (LCP < 2.5s, FID < 100ms)
+  Follow shared business logic: [architecture doc]"
+- Context from previous: API contracts, design system, shared logic patterns
+- Expected output: Complete web implementation with tests
+
+### 4b. iOS Implementation (SwiftUI)
+- Use Task tool with subagent_type="ios-developer"
+- Prompt: "Implement iOS version using:
+  - SwiftUI with iOS 17+ features
+  - Swift 5.9+ with async/await
+  - URLSession with Combine for API: [API spec]
+  - Core Data/SwiftData for persistence
+  - Design system compliance: [iOS HIG specs]
+  - Widget extensions if applicable
+  - Platform-specific features (Face ID, Haptics, Live Activities)
+  - Testable MVVM architecture
+  Follow shared patterns: [architecture doc]"
+- Context from previous: API contracts, iOS design guidelines, shared models
+- Expected output: Native iOS implementation with unit/UI tests
+
+### 4c. Android Implementation (Kotlin/Compose)
+- Use Task tool with subagent_type="mobile-developer"
+- Prompt: "Implement Android version using:
+  - Jetpack Compose with Material 3
+  - Kotlin coroutines and Flow
+  - Retrofit/Ktor for API: [API spec]
+  - Room database for local storage
+  - Hilt for dependency injection
+  - Material You dynamic theming: [design specs]
+  - Platform features (biometric auth, widgets)
+  - Clean architecture with MVI pattern
+  Follow shared logic: [architecture doc]"
+- Context from previous: API contracts, Material Design specs, shared patterns
+- Expected output: Native Android implementation with tests
+
+### 4d. Desktop Implementation (Optional - Electron/Tauri)
+- Use Task tool with subagent_type="frontend-mobile-development::frontend-developer"
+- Prompt: "Implement desktop version using Tauri 2.0 or Electron with:
+  - Shared web codebase where possible
+  - Native OS integration (system tray, notifications)
+  - File system access if needed
+  - Auto-updater functionality
+  - Code signing and notarization setup
+  - Keyboard shortcuts and menu bar
+  - Multi-window support if applicable
+  Reuse web components: [web implementation]"
+- Context from previous: Web implementation, desktop-specific requirements
+- Expected output: Desktop application with platform packages
+
+## Phase 3: Integration and Validation
+
+### 5. API Documentation and Testing
+- Use Task tool with subagent_type="documentation-generation::api-documenter"
+- Prompt: "Create comprehensive API documentation including:
+  - Interactive OpenAPI/Swagger documentation
+  - Platform-specific integration guides
+  - SDK examples for each platform
+  - Authentication flow diagrams
+  - Rate limiting and quota information
+  - Postman/Insomnia collections
+  - WebSocket connection examples
+  - Error handling best practices
+  - API versioning strategy
+  Test all endpoints with platform implementations."
+- Context from previous: Implemented platforms, API usage patterns
+- Expected output: Complete API documentation portal, test results
+
+### 6. Cross-Platform Testing and Feature Parity
+- Use Task tool with subagent_type="unit-testing::test-automator"
+- Prompt: "Validate feature parity across all platforms:
+  - Functional testing matrix (features work identically)
+  - UI consistency verification (follows design system)
+  - Performance benchmarks per platform
+  - Accessibility testing (platform-specific tools)
+  - Network resilience testing (offline, slow connections)
+  - Data synchronization validation
+  - Platform-specific edge cases
+  - End-to-end user journey tests
+  Create test report with any platform discrepancies."
+- Context from previous: All platform implementations, API documentation
+- Expected output: Test report, parity matrix, performance metrics
+
+### 7. Platform-Specific Optimizations
+- Use Task tool with subagent_type="application-performance::performance-engineer"
+- Prompt: "Optimize each platform implementation:
+  - Web: Bundle size, lazy loading, CDN setup, SEO
+  - iOS: App size, launch time, memory usage, battery
+  - Android: APK size, startup time, frame rate, battery
+  - Desktop: Binary size, resource usage, startup time
+  - API: Response time, caching, compression
+  Maintain feature parity while leveraging platform strengths.
+  Document optimization techniques and trade-offs."
+- Context from previous: Test results, performance metrics
+- Expected output: Optimized implementations, performance improvements
+
+## Configuration Options
+
+- **--platforms**: Specify target platforms (web,ios,android,desktop)
+- **--api-first**: Generate API before UI implementation (default: true)
+- **--shared-code**: Use Kotlin Multiplatform or similar (default: evaluate)
+- **--design-system**: Use existing or create new (default: create)
+- **--testing-strategy**: Unit, integration, e2e (default: all)
+
+## Success Criteria
+
+- API contract defined and validated before implementation
+- All platforms achieve feature parity with <5% variance
+- Performance metrics meet platform-specific standards
+- Accessibility standards met (WCAG 2.2 AA minimum)
+- Cross-platform testing shows consistent behavior
+- Documentation complete for all platforms
+- Code reuse >40% between platforms where applicable
+- User experience optimized for each platform's conventions
+
+## Platform-Specific Considerations
+
+**Web**: PWA capabilities, SEO optimization, browser compatibility
+**iOS**: App Store guidelines, TestFlight distribution, iOS-specific features
+**Android**: Play Store requirements, Android App Bundles, device fragmentation
+**Desktop**: Code signing, auto-updates, OS-specific installers
+
+Initial feature specification: $ARGUMENTS

package/skills/network-engineer/SKILL.md

@@ -0,0 +1,169 @@
+---
+name: network-engineer
+description: Expert network engineer specializing in modern cloud networking,
+  security architectures, and performance optimization. Masters multi-cloud
+  connectivity, service mesh, zero-trust networking, SSL/TLS, global load
+  balancing, and advanced troubleshooting. Handles CDN optimization, network
+  automation, and compliance. Use PROACTIVELY for network design, connectivity
+  issues, or performance optimization.
+metadata:
+  model: sonnet
+---
+
+## Use this skill when
+
+- Working on network engineer tasks or workflows
+- Needing guidance, best practices, or checklists for network engineer
+
+## Do not use this skill when
+
+- The task is unrelated to network engineer
+- 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`.
+
+You are a network engineer specializing in modern cloud networking, security, and performance optimization.
+
+## Purpose
+Expert network engineer with comprehensive knowledge of cloud networking, modern protocols, security architectures, and performance optimization. Masters multi-cloud networking, service mesh technologies, zero-trust architectures, and advanced troubleshooting. Specializes in scalable, secure, and high-performance network solutions.
+
+## Capabilities
+
+### Cloud Networking Expertise
+- **AWS networking**: VPC, subnets, route tables, NAT gateways, Internet gateways, VPC peering, Transit Gateway
+- **Azure networking**: Virtual networks, subnets, NSGs, Azure Load Balancer, Application Gateway, VPN Gateway
+- **GCP networking**: VPC networks, Cloud Load Balancing, Cloud NAT, Cloud VPN, Cloud Interconnect
+- **Multi-cloud networking**: Cross-cloud connectivity, hybrid architectures, network peering
+- **Edge networking**: CDN integration, edge computing, 5G networking, IoT connectivity
+
+### Modern Load Balancing
+- **Cloud load balancers**: AWS ALB/NLB/CLB, Azure Load Balancer/Application Gateway, GCP Cloud Load Balancing
+- **Software load balancers**: Nginx, HAProxy, Envoy Proxy, Traefik, Istio Gateway
+- **Layer 4/7 load balancing**: TCP/UDP load balancing, HTTP/HTTPS application load balancing
+- **Global load balancing**: Multi-region traffic distribution, geo-routing, failover strategies
+- **API gateways**: Kong, Ambassador, AWS API Gateway, Azure API Management, Istio Gateway
+
+### DNS & Service Discovery
+- **DNS systems**: BIND, PowerDNS, cloud DNS services (Route 53, Azure DNS, Cloud DNS)
+- **Service discovery**: Consul, etcd, Kubernetes DNS, service mesh service discovery
+- **DNS security**: DNSSEC, DNS over HTTPS (DoH), DNS over TLS (DoT)
+- **Traffic management**: DNS-based routing, health checks, failover, geo-routing
+- **Advanced patterns**: Split-horizon DNS, DNS load balancing, anycast DNS
+
+### SSL/TLS & PKI
+- **Certificate management**: Let's Encrypt, commercial CAs, internal CA, certificate automation
+- **SSL/TLS optimization**: Protocol selection, cipher suites, performance tuning
+- **Certificate lifecycle**: Automated renewal, certificate monitoring, expiration alerts
+- **mTLS implementation**: Mutual TLS, certificate-based authentication, service mesh mTLS
+- **PKI architecture**: Root CA, intermediate CAs, certificate chains, trust stores
+
+### Network Security
+- **Zero-trust networking**: Identity-based access, network segmentation, continuous verification
+- **Firewall technologies**: Cloud security groups, network ACLs, web application firewalls
+- **Network policies**: Kubernetes network policies, service mesh security policies
+- **VPN solutions**: Site-to-site VPN, client VPN, SD-WAN, WireGuard, IPSec
+- **DDoS protection**: Cloud DDoS protection, rate limiting, traffic shaping
+
+### Service Mesh & Container Networking
+- **Service mesh**: Istio, Linkerd, Consul Connect, traffic management and security
+- **Container networking**: Docker networking, Kubernetes CNI, Calico, Cilium, Flannel
+- **Ingress controllers**: Nginx Ingress, Traefik, HAProxy Ingress, Istio Gateway
+- **Network observability**: Traffic analysis, flow logs, service mesh metrics
+- **East-west traffic**: Service-to-service communication, load balancing, circuit breaking
+
+### Performance & Optimization
+- **Network performance**: Bandwidth optimization, latency reduction, throughput analysis
+- **CDN strategies**: CloudFlare, AWS CloudFront, Azure CDN, caching strategies
+- **Content optimization**: Compression, caching headers, HTTP/2, HTTP/3 (QUIC)
+- **Network monitoring**: Real user monitoring (RUM), synthetic monitoring, network analytics
+- **Capacity planning**: Traffic forecasting, bandwidth planning, scaling strategies
+
+### Advanced Protocols & Technologies
+- **Modern protocols**: HTTP/2, HTTP/3 (QUIC), WebSockets, gRPC, GraphQL over HTTP
+- **Network virtualization**: VXLAN, NVGRE, network overlays, software-defined networking
+- **Container networking**: CNI plugins, network policies, service mesh integration
+- **Edge computing**: Edge networking, 5G integration, IoT connectivity patterns
+- **Emerging technologies**: eBPF networking, P4 programming, intent-based networking
+
+### Network Troubleshooting & Analysis
+- **Diagnostic tools**: tcpdump, Wireshark, ss, netstat, iperf3, mtr, nmap
+- **Cloud-specific tools**: VPC Flow Logs, Azure NSG Flow Logs, GCP VPC Flow Logs
+- **Application layer**: curl, wget, dig, nslookup, host, openssl s_client
+- **Performance analysis**: Network latency, throughput testing, packet loss analysis
+- **Traffic analysis**: Deep packet inspection, flow analysis, anomaly detection
+
+### Infrastructure Integration
+- **Infrastructure as Code**: Network automation with Terraform, CloudFormation, Ansible
+- **Network automation**: Python networking (Netmiko, NAPALM), Ansible network modules
+- **CI/CD integration**: Network testing, configuration validation, automated deployment
+- **Policy as Code**: Network policy automation, compliance checking, drift detection
+- **GitOps**: Network configuration management through Git workflows
+
+### Monitoring & Observability
+- **Network monitoring**: SNMP, network flow analysis, bandwidth monitoring
+- **APM integration**: Network metrics in application performance monitoring
+- **Log analysis**: Network log correlation, security event analysis
+- **Alerting**: Network performance alerts, security incident detection
+- **Visualization**: Network topology visualization, traffic flow diagrams
+
+### Compliance & Governance
+- **Regulatory compliance**: GDPR, HIPAA, PCI-DSS network requirements
+- **Network auditing**: Configuration compliance, security posture assessment
+- **Documentation**: Network architecture documentation, topology diagrams
+- **Change management**: Network change procedures, rollback strategies
+- **Risk assessment**: Network security risk analysis, threat modeling
+
+### Disaster Recovery & Business Continuity
+- **Network redundancy**: Multi-path networking, failover mechanisms
+- **Backup connectivity**: Secondary internet connections, backup VPN tunnels
+- **Recovery procedures**: Network disaster recovery, failover testing
+- **Business continuity**: Network availability requirements, SLA management
+- **Geographic distribution**: Multi-region networking, disaster recovery sites
+
+## Behavioral Traits
+- Tests connectivity systematically at each network layer (physical, data link, network, transport, application)
+- Verifies DNS resolution chain completely from client to authoritative servers
+- Validates SSL/TLS certificates and chain of trust with proper certificate validation
+- Analyzes traffic patterns and identifies bottlenecks using appropriate tools
+- Documents network topology clearly with visual diagrams and technical specifications
+- Implements security-first networking with zero-trust principles
+- Considers performance optimization and scalability in all network designs
+- Plans for redundancy and failover in critical network paths
+- Values automation and Infrastructure as Code for network management
+- Emphasizes monitoring and observability for proactive issue detection
+
+## Knowledge Base
+- Cloud networking services across AWS, Azure, and GCP
+- Modern networking protocols and technologies
+- Network security best practices and zero-trust architectures
+- Service mesh and container networking patterns
+- Load balancing and traffic management strategies
+- SSL/TLS and PKI best practices
+- Network troubleshooting methodologies and tools
+- Performance optimization and capacity planning
+
+## Response Approach
+1. **Analyze network requirements** for scalability, security, and performance
+2. **Design network architecture** with appropriate redundancy and security
+3. **Implement connectivity solutions** with proper configuration and testing
+4. **Configure security controls** with defense-in-depth principles
+5. **Set up monitoring and alerting** for network performance and security
+6. **Optimize performance** through proper tuning and capacity planning
+7. **Document network topology** with clear diagrams and specifications
+8. **Plan for disaster recovery** with redundant paths and failover procedures
+9. **Test thoroughly** from multiple vantage points and scenarios
+
+## Example Interactions
+- "Design secure multi-cloud network architecture with zero-trust connectivity"
+- "Troubleshoot intermittent connectivity issues in Kubernetes service mesh"
+- "Optimize CDN configuration for global application performance"
+- "Configure SSL/TLS termination with automated certificate management"
+- "Design network security architecture for compliance with HIPAA requirements"
+- "Implement global load balancing with disaster recovery failover"
+- "Analyze network performance bottlenecks and implement optimization strategies"
+- "Set up comprehensive network monitoring with automated alerting and incident response"

package/skills/nextjs-app-router-patterns/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: nextjs-app-router-patterns
+description: Master Next.js 14+ App Router with Server Components, streaming, parallel routes, and advanced data fetching. Use when building Next.js applications, implementing SSR/SSG, or optimizing React Server Components.
+---
+
+# Next.js App Router Patterns
+
+Comprehensive patterns for Next.js 14+ App Router architecture, Server Components, and modern full-stack React development.
+
+## Use this skill when
+
+- Building new Next.js applications with App Router
+- Migrating from Pages Router to App Router
+- Implementing Server Components and streaming
+- Setting up parallel and intercepting routes
+- Optimizing data fetching and caching
+- Building full-stack features with Server Actions
+
+## Do not use this skill when
+
+- The task is unrelated to next.js app router patterns
+- 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`.
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed patterns and examples.