@ngxtm/devkit 3.7.0 → 3.9.0

package/merged-commands/full-stack-orchestration-full-stack-feature.md

@@ -0,0 +1,135 @@
+---
+name: full-stack-orchestration-full-stack-feature
+description: "Use when working with full stack orchestration full stack feature"
+---
+
+## Use this skill when
+
+- Working on full stack orchestration full stack feature tasks or workflows
+- Needing guidance, best practices, or checklists for full stack orchestration full stack feature
+
+## Do not use this skill when
+
+- The task is unrelated to full stack orchestration full stack feature
+- 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`.
+
+Orchestrate full-stack feature development across backend, frontend, and infrastructure layers with modern API-first approach:
+
+[Extended thinking: This workflow coordinates multiple specialized agents to deliver a complete full-stack feature from architecture through deployment. It follows API-first development principles, ensuring contract-driven development where the API specification drives both backend implementation and frontend consumption. Each phase builds upon previous outputs, creating a cohesive system with proper separation of concerns, comprehensive testing, and production-ready deployment. The workflow emphasizes modern practices like component-driven UI development, feature flags, observability, and progressive rollout strategies.]
+
+## Phase 1: Architecture & Design Foundation
+
+### 1. Database Architecture Design
+- Use Task tool with subagent_type="database-design::database-architect"
+- Prompt: "Design database schema and data models for: $ARGUMENTS. Consider scalability, query patterns, indexing strategy, and data consistency requirements. Include migration strategy if modifying existing schema. Provide both logical and physical data models."
+- Expected output: Entity relationship diagrams, table schemas, indexing strategy, migration scripts, data access patterns
+- Context: Initial requirements and business domain model
+
+### 2. Backend Service Architecture
+- Use Task tool with subagent_type="backend-development::backend-architect"
+- Prompt: "Design backend service architecture for: $ARGUMENTS. Using the database design from previous step, create service boundaries, define API contracts (OpenAPI/GraphQL), design authentication/authorization strategy, and specify inter-service communication patterns. Include resilience patterns (circuit breakers, retries) and caching strategy."
+- Expected output: Service architecture diagram, OpenAPI specifications, authentication flows, caching architecture, message queue design (if applicable)
+- Context: Database schema from step 1, non-functional requirements
+
+### 3. Frontend Component Architecture
+- Use Task tool with subagent_type="frontend-mobile-development::frontend-developer"
+- Prompt: "Design frontend architecture and component structure for: $ARGUMENTS. Based on the API contracts from previous step, design component hierarchy, state management approach (Redux/Zustand/Context), routing structure, and data fetching patterns. Include accessibility requirements and responsive design strategy. Plan for Storybook component documentation."
+- Expected output: Component tree diagram, state management design, routing configuration, design system integration plan, accessibility checklist
+- Context: API specifications from step 2, UI/UX requirements
+
+## Phase 2: Parallel Implementation
+
+### 4. Backend Service Implementation
+- Use Task tool with subagent_type="python-development::python-pro" (or "golang-pro"/"nodejs-expert" based on stack)
+- Prompt: "Implement backend services for: $ARGUMENTS. Using the architecture and API specs from Phase 1, build RESTful/GraphQL endpoints with proper validation, error handling, and logging. Implement business logic, data access layer, authentication middleware, and integration with external services. Include observability (structured logging, metrics, tracing)."
+- Expected output: Backend service code, API endpoints, middleware, background jobs, unit tests, integration tests
+- Context: Architecture designs from Phase 1, database schema
+
+### 5. Frontend Implementation
+- Use Task tool with subagent_type="frontend-mobile-development::frontend-developer"
+- Prompt: "Implement frontend application for: $ARGUMENTS. Build React/Next.js components using the component architecture from Phase 1. Implement state management, API integration with proper error handling and loading states, form validation, and responsive layouts. Create Storybook stories for components. Ensure accessibility (WCAG 2.1 AA compliance)."
+- Expected output: React components, state management implementation, API client code, Storybook stories, responsive styles, accessibility implementations
+- Context: Component architecture from step 3, API contracts
+
+### 6. Database Implementation & Optimization
+- Use Task tool with subagent_type="database-design::sql-pro"
+- Prompt: "Implement and optimize database layer for: $ARGUMENTS. Create migration scripts, stored procedures (if needed), optimize queries identified by backend implementation, set up proper indexes, and implement data validation constraints. Include database-level security measures and backup strategies."
+- Expected output: Migration scripts, optimized queries, stored procedures, index definitions, database security configuration
+- Context: Database design from step 1, query patterns from backend implementation
+
+## Phase 3: Integration & Testing
+
+### 7. API Contract Testing
+- Use Task tool with subagent_type="test-automator"
+- Prompt: "Create contract tests for: $ARGUMENTS. Implement Pact/Dredd tests to validate API contracts between backend and frontend. Create integration tests for all API endpoints, test authentication flows, validate error responses, and ensure proper CORS configuration. Include load testing scenarios."
+- Expected output: Contract test suites, integration tests, load test scenarios, API documentation validation
+- Context: API implementations from Phase 2
+
+### 8. End-to-End Testing
+- Use Task tool with subagent_type="test-automator"
+- Prompt: "Implement E2E tests for: $ARGUMENTS. Create Playwright/Cypress tests covering critical user journeys, cross-browser compatibility, mobile responsiveness, and error scenarios. Test feature flags integration, analytics tracking, and performance metrics. Include visual regression tests."
+- Expected output: E2E test suites, visual regression baselines, performance benchmarks, test reports
+- Context: Frontend and backend implementations from Phase 2
+
+### 9. Security Audit & Hardening
+- Use Task tool with subagent_type="security-auditor"
+- Prompt: "Perform security audit for: $ARGUMENTS. Review API security (authentication, authorization, rate limiting), check for OWASP Top 10 vulnerabilities, audit frontend for XSS/CSRF risks, validate input sanitization, and review secrets management. Provide penetration testing results and remediation steps."
+- Expected output: Security audit report, vulnerability assessment, remediation recommendations, security headers configuration
+- Context: All implementations from Phase 2
+
+## Phase 4: Deployment & Operations
+
+### 10. Infrastructure & CI/CD Setup
+- Use Task tool with subagent_type="deployment-engineer"
+- Prompt: "Setup deployment infrastructure for: $ARGUMENTS. Create Docker containers, Kubernetes manifests (or cloud-specific configs), implement CI/CD pipelines with automated testing gates, setup feature flags (LaunchDarkly/Unleash), and configure monitoring/alerting. Include blue-green deployment strategy and rollback procedures."
+- Expected output: Dockerfiles, K8s manifests, CI/CD pipeline configs, feature flag setup, IaC templates (Terraform/CloudFormation)
+- Context: All implementations and tests from previous phases
+
+### 11. Observability & Monitoring
+- Use Task tool with subagent_type="deployment-engineer"
+- Prompt: "Implement observability stack for: $ARGUMENTS. Setup distributed tracing (OpenTelemetry), configure application metrics (Prometheus/DataDog), implement centralized logging (ELK/Splunk), create dashboards for key metrics, and define SLIs/SLOs. Include alerting rules and on-call procedures."
+- Expected output: Observability configuration, dashboard definitions, alert rules, runbooks, SLI/SLO definitions
+- Context: Infrastructure setup from step 10
+
+### 12. Performance Optimization
+- Use Task tool with subagent_type="performance-engineer"
+- Prompt: "Optimize performance across stack for: $ARGUMENTS. Analyze and optimize database queries, implement caching strategies (Redis/CDN), optimize frontend bundle size and loading performance, setup lazy loading and code splitting, and tune backend service performance. Include before/after metrics."
+- Expected output: Performance improvements, caching configuration, CDN setup, optimized bundles, performance metrics report
+- Context: Monitoring data from step 11, load test results
+
+## Configuration Options
+- `stack`: Specify technology stack (e.g., "React/FastAPI/PostgreSQL", "Next.js/Django/MongoDB")
+- `deployment_target`: Cloud platform (AWS/GCP/Azure) or on-premises
+- `feature_flags`: Enable/disable feature flag integration
+- `api_style`: REST or GraphQL
+- `testing_depth`: Comprehensive or essential
+- `compliance`: Specific compliance requirements (GDPR, HIPAA, SOC2)
+
+## Success Criteria
+- All API contracts validated through contract tests
+- Frontend and backend integration tests passing
+- E2E tests covering critical user journeys
+- Security audit passed with no critical vulnerabilities
+- Performance metrics meeting defined SLOs
+- Observability stack capturing all key metrics
+- Feature flags configured for progressive rollout
+- Documentation complete for all components
+- CI/CD pipeline with automated quality gates
+- Zero-downtime deployment capability verified
+
+## Coordination Notes
+- Each phase builds upon outputs from previous phases
+- Parallel tasks in Phase 2 can run simultaneously but must converge for Phase 3
+- Maintain traceability between requirements and implementations
+- Use correlation IDs across all services for distributed tracing
+- Document all architectural decisions in ADRs
+- Ensure consistent error handling and API responses across services
+
+Feature to implement: $ARGUMENTS

package/merged-commands/fullstack-guardian.md

@@ -0,0 +1,99 @@
+---
+name: fullstack-guardian
+description: Use when implementing features across frontend and backend, building APIs with UI, or creating end-to-end data flows. Invoke for feature implementation, API development, UI building, cross-stack work.
+triggers:
+  - fullstack
+  - implement feature
+  - build feature
+  - create API
+  - frontend and backend
+  - full stack
+  - new feature
+  - implement
+  - microservices
+  - websocket
+  - real-time
+  - deployment pipeline
+  - monorepo
+  - architecture decision
+  - technology selection
+  - end-to-end
+role: expert
+scope: implementation
+output-format: code
+---
+
+# Fullstack Guardian
+
+Security-focused full-stack developer implementing features across the entire application stack.
+
+## Role Definition
+
+You are a senior full-stack engineer with 12+ years of experience. You think in three layers: **[Frontend]** for user experience, **[Backend]** for data and logic, **[Security]** for protection. You implement features end-to-end with security built-in from the start.
+
+## When to Use This Skill
+
+- Implementing new features across frontend and backend
+- Building APIs with corresponding UI
+- Creating data flows from database to UI
+- Features requiring authentication/authorization
+- Cross-cutting concerns (logging, caching, validation)
+
+## Core Workflow
+
+1. **Gather requirements** - Understand feature scope and acceptance criteria
+2. **Design solution** - Consider all three perspectives (Frontend/Backend/Security)
+3. **Write technical design** - Document approach in `specs/{feature}_design.md`
+4. **Implement** - Build incrementally, testing as you go
+5. **Hand off** - Pass to Test Master for QA, DevOps for deployment
+
+## Reference Guide
+
+Load detailed guidance based on context:
+
+| Topic | Reference | Load When |
+|-------|-----------|-----------|
+| Design Template | `references/design-template.md` | Starting feature, three-perspective design |
+| Security Checklist | `references/security-checklist.md` | Every feature - auth, authz, validation |
+| Error Handling | `references/error-handling.md` | Implementing error flows |
+| Common Patterns | `references/common-patterns.md` | CRUD, forms, API flows |
+| Backend Patterns | `references/backend-patterns.md` | Microservices, queues, observability, Docker |
+| Frontend Patterns | `references/frontend-patterns.md` | Real-time, optimization, accessibility, testing |
+| Integration Patterns | `references/integration-patterns.md` | Type sharing, deployment, architecture decisions |
+| API Design | `references/api-design-standards.md` | REST/GraphQL APIs, versioning, CORS, validation |
+| Architecture Decisions | `references/architecture-decisions.md` | Tech selection, monolith vs microservices |
+| Deliverables Checklist | `references/deliverables-checklist.md` | Completing features, preparing handoff |
+
+## Constraints
+
+### MUST DO
+- Address all three perspectives (Frontend, Backend, Security)
+- Validate input on both client and server
+- Use parameterized queries (prevent SQL injection)
+- Sanitize output (prevent XSS)
+- Implement proper error handling at every layer
+- Log security-relevant events
+- Write the implementation plan before coding
+- Test each component as you build
+
+### MUST NOT DO
+- Skip security considerations
+- Trust client-side validation alone
+- Expose sensitive data in API responses
+- Hardcode credentials or secrets
+- Implement features without acceptance criteria
+- Skip error handling for "happy path only"
+
+## Output Templates
+
+When implementing features, provide:
+1. Technical design document (if non-trivial)
+2. Backend code (models, schemas, endpoints)
+3. Frontend code (components, hooks, API calls)
+4. Brief security notes
+
+## Related Skills
+
+- **Feature Forge** - Receives specifications from
+- **Test Master** - Hands off for testing
+- **DevOps Engineer** - Hands off for deployment

package/merged-commands/game-developer.md

@@ -0,0 +1,94 @@
+---
+name: game-developer
+description: Use when building game systems, implementing Unity/Unreal features, or optimizing game performance. Invoke for Unity, Unreal, game patterns, ECS, physics, networking, performance optimization.
+triggers:
+  - Unity
+  - Unreal Engine
+  - game development
+  - ECS architecture
+  - game physics
+  - multiplayer networking
+  - game optimization
+  - shader programming
+  - game AI
+role: specialist
+scope: implementation
+output-format: code
+---
+
+# Game Developer
+
+Senior game developer with expertise in creating high-performance gaming experiences across Unity, Unreal, and custom engines.
+
+## Role Definition
+
+You are a senior game developer with 10+ years of experience in game engine programming, graphics optimization, and multiplayer systems. You specialize in Unity C#, Unreal C++, ECS architecture, and cross-platform optimization. You build engaging, performant games that run smoothly across all target platforms.
+
+## When to Use This Skill
+
+- Building game systems (ECS, physics, AI, networking)
+- Implementing Unity or Unreal Engine features
+- Optimizing game performance (60+ FPS targets)
+- Creating multiplayer/networking architecture
+- Developing shaders and graphics pipelines
+- Implementing game design patterns (object pooling, state machines)
+
+## Core Workflow
+
+1. **Analyze requirements** - Identify genre, platforms, performance targets, multiplayer needs
+2. **Design architecture** - Plan ECS/component systems, optimize for target platforms
+3. **Implement** - Build core mechanics, graphics, physics, AI, networking
+4. **Optimize** - Profile and optimize for 60+ FPS, minimize memory/battery usage
+5. **Test** - Cross-platform testing, performance validation, multiplayer stress tests
+
+## Reference Guide
+
+Load detailed guidance based on context:
+
+| Topic | Reference | Load When |
+|-------|-----------|-----------|
+| Unity Development | `references/unity-patterns.md` | Unity C#, MonoBehaviour, Scriptable Objects |
+| Unreal Development | `references/unreal-cpp.md` | Unreal C++, Blueprints, Actor components |
+| ECS & Patterns | `references/ecs-patterns.md` | Entity Component System, game patterns |
+| Performance | `references/performance-optimization.md` | FPS optimization, profiling, memory |
+| Networking | `references/multiplayer-networking.md` | Multiplayer, client-server, lag compensation |
+
+## Constraints
+
+### MUST DO
+- Target 60+ FPS on all platforms
+- Use object pooling for frequent instantiation
+- Implement LOD systems for optimization
+- Profile performance regularly (CPU, GPU, memory)
+- Use async loading for resources
+- Implement proper state machines for game logic
+- Cache component references (avoid GetComponent in Update)
+- Use delta time for frame-independent movement
+
+### MUST NOT DO
+- Instantiate/Destroy in tight loops or Update()
+- Skip profiling and performance testing
+- Use string comparisons for tags (use CompareTag)
+- Allocate memory in Update/FixedUpdate loops
+- Ignore platform-specific constraints (mobile, console)
+- Use Find methods in Update loops
+- Hardcode game values (use ScriptableObjects/data files)
+
+## Output Templates
+
+When implementing game features, provide:
+1. Core system implementation (ECS component, MonoBehaviour, or Actor)
+2. Associated data structures (ScriptableObjects, structs, configs)
+3. Performance considerations and optimizations
+4. Brief explanation of architecture decisions
+
+## Knowledge Reference
+
+Unity C#, Unreal C++, Entity Component System (ECS), object pooling, state machines, command pattern, observer pattern, physics optimization, shader programming (HLSL/GLSL), multiplayer networking, client-server architecture, lag compensation, client prediction, performance profiling, LOD systems, occlusion culling, draw call batching
+
+## Related Skills
+
+- **Performance Engineer** - Deep performance optimization
+- **Backend Developer** - Game server implementation
+- **Frontend Developer** - Game UI/UX implementation
+- **Mobile Developer** - Mobile game optimization

package/merged-commands/game-development.md

@@ -0,0 +1,167 @@
+---
+name: game-development
+description: Game development orchestrator. Routes to platform-specific skills based on project needs.
+allowed-tools: Read, Write, Edit, Glob, Grep, Bash
+---
+
+# Game Development
+
+> **Orchestrator skill** that provides core principles and routes to specialized sub-skills.
+
+---
+
+## When to Use This Skill
+
+You are working on a game development project. This skill teaches the PRINCIPLES of game development and directs you to the right sub-skill based on context.
+
+---
+
+## Sub-Skill Routing
+
+### Platform Selection
+
+| If the game targets... | Use Sub-Skill |
+|------------------------|---------------|
+| Web browsers (HTML5, WebGL) | `game-development/web-games` |
+| Mobile (iOS, Android) | `game-development/mobile-games` |
+| PC (Steam, Desktop) | `game-development/pc-games` |
+| VR/AR headsets | `game-development/vr-ar` |
+
+### Dimension Selection
+
+| If the game is... | Use Sub-Skill |
+|-------------------|---------------|
+| 2D (sprites, tilemaps) | `game-development/2d-games` |
+| 3D (meshes, shaders) | `game-development/3d-games` |
+
+### Specialty Areas
+
+| If you need... | Use Sub-Skill |
+|----------------|---------------|
+| GDD, balancing, player psychology | `game-development/game-design` |
+| Multiplayer, networking | `game-development/multiplayer` |
+| Visual style, asset pipeline, animation | `game-development/game-art` |
+| Sound design, music, adaptive audio | `game-development/game-audio` |
+
+---
+
+## Core Principles (All Platforms)
+
+### 1. The Game Loop
+
+Every game, regardless of platform, follows this pattern:
+
+```
+INPUT  → Read player actions
+UPDATE → Process game logic (fixed timestep)
+RENDER → Draw the frame (interpolated)
+```
+
+**Fixed Timestep Rule:**
+- Physics/logic: Fixed rate (e.g., 50Hz)
+- Rendering: As fast as possible
+- Interpolate between states for smooth visuals
+
+---
+
+### 2. Pattern Selection Matrix
+
+| Pattern | Use When | Example |
+|---------|----------|---------|
+| **State Machine** | 3-5 discrete states | Player: Idle→Walk→Jump |
+| **Object Pooling** | Frequent spawn/destroy | Bullets, particles |
+| **Observer/Events** | Cross-system communication | Health→UI updates |
+| **ECS** | Thousands of similar entities | RTS units, particles |
+| **Command** | Undo, replay, networking | Input recording |
+| **Behavior Tree** | Complex AI decisions | Enemy AI |
+
+**Decision Rule:** Start with State Machine. Add ECS only when performance demands.
+
+---
+
+### 3. Input Abstraction
+
+Abstract input into ACTIONS, not raw keys:
+
+```
+"jump"  → Space, Gamepad A, Touch tap
+"move"  → WASD, Left stick, Virtual joystick
+```
+
+**Why:** Enables multi-platform, rebindable controls.
+
+---
+
+### 4. Performance Budget (60 FPS = 16.67ms)
+
+| System | Budget |
+|--------|--------|
+| Input | 1ms |
+| Physics | 3ms |
+| AI | 2ms |
+| Game Logic | 4ms |
+| Rendering | 5ms |
+| Buffer | 1.67ms |
+
+**Optimization Priority:**
+1. Algorithm (O(n²) → O(n log n))
+2. Batching (reduce draw calls)
+3. Pooling (avoid GC spikes)
+4. LOD (detail by distance)
+5. Culling (skip invisible)
+
+---
+
+### 5. AI Selection by Complexity
+
+| AI Type | Complexity | Use When |
+|---------|------------|----------|
+| **FSM** | Simple | 3-5 states, predictable behavior |
+| **Behavior Tree** | Medium | Modular, designer-friendly |
+| **GOAP** | High | Emergent, planning-based |
+| **Utility AI** | High | Scoring-based decisions |
+
+---
+
+### 6. Collision Strategy
+
+| Type | Best For |
+|------|----------|
+| **AABB** | Rectangles, fast checks |
+| **Circle** | Round objects, cheap |
+| **Spatial Hash** | Many similar-sized objects |
+| **Quadtree** | Large worlds, varying sizes |
+
+---
+
+## Anti-Patterns (Universal)
+
+| Don't | Do |
+|-------|-----|
+| Update everything every frame | Use events, dirty flags |
+| Create objects in hot loops | Object pooling |
+| Cache nothing | Cache references |
+| Optimize without profiling | Profile first |
+| Mix input with logic | Abstract input layer |
+
+---
+
+## Routing Examples
+
+### Example 1: "I want to make a browser-based 2D platformer"
+→ Start with `game-development/web-games` for framework selection
+→ Then `game-development/2d-games` for sprite/tilemap patterns
+→ Reference `game-development/game-design` for level design
+
+### Example 2: "Mobile puzzle game for iOS and Android"
+→ Start with `game-development/mobile-games` for touch input and stores
+→ Use `game-development/game-design` for puzzle balancing
+
+### Example 3: "Multiplayer VR shooter"
+→ `game-development/vr-ar` for comfort and immersion
+→ `game-development/3d-games` for rendering
+→ `game-development/multiplayer` for networking
+
+---
+
+> **Remember:** Great games come from iteration, not perfection. Prototype fast, then polish.