claude-code-templates 1.21.6 → 1.21.8

package/components/commands/documentation/update-docs.md

@@ -1,107 +0,0 @@
----
-allowed-tools: Read, Write, Edit, Bash
-argument-hint: [doc-type] | --implementation | --api | --architecture | --sync | --validate
-description: Systematically update project documentation with implementation status, API changes, and synchronized content
-model: sonnet
----
-
-# Documentation Update & Synchronization
-
-Update project documentation systematically: $ARGUMENTS
-
-## Current Documentation State
-
-- Documentation structure: !`find . -name "*.md" | head -10`
-- Specs directory: @specs/ (if exists)
-- Implementation status: !`grep -r "✅\|❌\|⚠️" docs/ specs/ 2>/dev/null | wc -l` status indicators
-- Recent changes: !`git log --oneline --since="1 week ago" -- "*.md" | head -5`
-- Project progress: @CLAUDE.md or @README.md (if exists)
-
-## Task
-
-## Documentation Analysis
-
-1. Review current documentation status:
-   - Check `specs/implementation_status.md` for overall project status
-   - Review implemented phase document (`specs/phase{N}_implementation_plan.md`)
-   - Review `specs/flutter_structurizr_implementation_spec.md` and `specs/flutter_structurizr_implementation_spec_updated.md`
-   - Review `specs/testing_plan.md` to ensure it is current given recent test passes, failures, and changes
-   - Examine `CLAUDE.md` and `README.md` for project-wide documentation
-   - Check for and document any new lessons learned or best practices in CLAUDE.md
-
-2. Analyze implementation and testing results:
-   - Review what was implemented in the last phase
-   - Review testing results and coverage
-   - Identify new best practices discovered during implementation
-   - Note any implementation challenges and solutions
-   - Cross-reference updated documentation with recent implementation and test results to ensure accuracy
-
-## Documentation Updates
-
-1. Update phase implementation document:
-   - Mark completed tasks with ✅ status
-   - Update implementation percentages
-   - Add detailed notes on implementation approach
-   - Document any deviations from original plan with justification
-   - Add new sections if needed (lessons learned, best practices)
-   - Document specific implementation details for complex components
-   - Include a summary of any new troubleshooting tips or workflow improvements discovered during the phase
-
-2. Update implementation status document:
-   - Update phase completion percentages
-   - Add or update implementation status for components
-   - Add notes on implementation approach and decisions
-   - Document best practices discovered during implementation
-   - Note any challenges overcome and solutions implemented
-
-3. Update implementation specification documents:
-   - Mark completed items with ✅ or strikethrough but preserve original requirements
-   - Add notes on implementation details where appropriate
-   - Add references to implemented files and classes
-   - Update any implementation guidance based on experience
-
-4. Update CLAUDE.md and README.md if necessary:
-   - Add new best practices
-   - Update project status
-   - Add new implementation guidance
-   - Document known issues or limitations
-   - Update usage examples to include new functionality
-
-5. Document new testing procedures:
-   - Add details on test files created
-   - Include test running instructions
-   - Document test coverage
-   - Explain testing approach for complex components
-
-## Documentation Formatting and Structure
-
-1. Maintain consistent documentation style:
-   - Use clear headings and sections
-   - Include code examples where helpful
-   - Use status indicators (✅, ⚠️, ❌) consistently
-   - Maintain proper Markdown formatting
-
-2. Ensure documentation completeness:
-   - Cover all implemented features
-   - Include usage examples
-   - Document API changes or additions
-   - Include troubleshooting guidance for common issues
-
-## Guidelines
-
-- DO NOT CREATE new specification files
-- UPDATE existing files in the `specs/` directory
-- Maintain consistent documentation style
-- Include practical examples where appropriate
-- Cross-reference related documentation sections
-- Document best practices and lessons learned
-- Provide clear status updates on project progress
-- Update numerical completion percentages
-- Ensure documentation reflects actual implementation
-
-Provide a summary of documentation updates after completion, including:
-1. Files updated
-2. Major changes to documentation
-3. Updated completion percentages
-4. New best practices documented
-5. Status of the overall project after this phase

package/components/commands/game-development/game-analytics-integration.md

@@ -1,128 +0,0 @@
----
-allowed-tools: Read, Write, Edit, Bash
-argument-hint: [analytics-type] | --player-behavior | --performance | --monetization | --retention | --comprehensive
-description: Use PROACTIVELY to implement game analytics systems with player behavior tracking, performance monitoring, and business intelligence integration
-model: sonnet
----
-
-# Game Analytics & Player Intelligence System
-
-Implement comprehensive game analytics and player intelligence: $ARGUMENTS
-
-## Current Analytics Context
-
-- Game platform: @package.json or detect Unity/Unreal/Godot project files
-- Existing analytics: !`grep -r "Analytics\|Telemetry\|Tracking" . 2>/dev/null | wc -l` current implementations
-- Data storage: @database/ or detect database configurations
-- Privacy compliance: @privacy-policy.md or @GDPR/ (if exists)
-- Platform SDKs: !`find . -name "*SDK*" -o -name "*Analytics*" | head -5`
-
-## Task
-
-Create a comprehensive analytics system for game development with player behavior tracking, performance monitoring, A/B testing capabilities, and business intelligence integration.
-
-## Analytics Framework Components
-
-### 1. Player Behavior Analytics
-- Session tracking and engagement metrics
-- User journey mapping and funnel analysis
-- Feature usage and interaction heatmaps
-- Player progression and achievement tracking
-- Social interactions and community engagement metrics
-
-### 2. Performance & Technical Analytics
-- Frame rate and performance monitoring across devices
-- Crash reporting and error tracking
-- Loading times and optimization opportunities
-- Memory usage patterns and optimization insights
-- Network performance and connectivity analytics
-
-### 3. Business Intelligence Integration
-- Revenue tracking and monetization analytics
-- User acquisition and retention metrics
-- Lifetime value (LTV) and cohort analysis
-- A/B testing framework for feature experiments
-- Market segmentation and player persona analytics
-
-### 4. Real-time Monitoring & Alerting
-- Live player activity monitoring
-- Performance anomaly detection and alerting
-- Revenue and conversion rate monitoring
-- Server health and capacity monitoring
-- Automated incident response and escalation
-
-## Analytics Implementation Areas
-
-### Data Collection Strategy
-- Event taxonomy design and standardization
-- Privacy-compliant data collection practices
-- Cross-platform data synchronization
-- Offline data storage and batch upload
-- Data quality validation and cleansing
-
-### Analytics Dashboard Development
-- Real-time analytics visualization
-- Custom KPI tracking and monitoring
-- Executive and stakeholder reporting
-- Team-specific analytics views and permissions
-- Mobile and web dashboard accessibility
-
-### Player Insights & Segmentation
-- Player behavior pattern analysis
-- Churn prediction and retention strategies
-- Personalization and recommendation systems
-- Dynamic difficulty adjustment based on analytics
-- Player support and community management insights
-
-### A/B Testing & Experimentation
-- Feature flag management and testing infrastructure
-- Statistical significance validation
-- Multivariate testing capabilities
-- Gradual feature rollout and monitoring
-- Experiment result analysis and recommendations
-
-## Privacy & Compliance
-
-### Data Protection Implementation
-- GDPR and CCPA compliance frameworks
-- User consent management and tracking
-- Data anonymization and pseudonymization
-- Right to be forgotten implementation
-- Data breach detection and response procedures
-
-### Security & Data Governance
-- Encrypted data transmission and storage
-- Access control and audit logging
-- Data retention policy implementation
-- Third-party integration security validation
-- Regular security assessment and compliance audits
-
-## Deliverables
-
-1. **Analytics Architecture**
-   - Data collection framework and event taxonomy
-   - Privacy-compliant implementation guidelines
-   - Cross-platform synchronization strategy
-   - Real-time processing and storage architecture
-
-2. **Dashboard & Reporting System**
-   - Executive and operational dashboards
-   - Automated reporting and alert systems
-   - Custom analytics views for different stakeholders
-   - Mobile and web accessibility implementation
-
-3. **Player Intelligence Platform**
-   - Behavior analysis and segmentation tools
-   - Predictive analytics and recommendation systems
-   - A/B testing and experimentation framework
-   - Personalization and dynamic content delivery
-
-4. **Compliance & Security Framework**
-   - Privacy policy and consent management
-   - Data governance and security protocols
-   - Regulatory compliance validation
-   - Incident response and data breach procedures
-
-## Integration Guidelines
-
-Implement analytics with game engine native solutions and establish scalable data pipelines. Ensure compliance with privacy regulations and platform-specific requirements while maintaining player trust and data security.

package/components/commands/game-development/game-asset-pipeline.md

@@ -1,108 +0,0 @@
----
-allowed-tools: Read, Write, Edit, Bash
-argument-hint: [pipeline-type] | --art | --audio | --models | --textures | --comprehensive
-description: Use PROACTIVELY to build automated game asset processing pipelines with optimization, validation, and multi-platform delivery systems
-model: sonnet
----
-
-# Game Asset Pipeline & Processing System
-
-Build comprehensive game asset processing pipeline: $ARGUMENTS
-
-## Current Asset Environment
-
-- Project assets: !`find . -name "*.png" -o -name "*.fbx" -o -name "*.wav" -o -name "*.mp3" | wc -l` total assets
-- Asset sizes: !`du -sh Assets/ 2>/dev/null || du -sh assets/ 2>/dev/null || echo "No assets folder found"`
-- Build tools: !`which blender`; !`which ffmpeg`; !`which imagemagick`
-- Platform targets: @ProjectSettings/ProjectSettings.asset or detect from build configs
-- Version control: !`git lfs ls-files | wc -l` LFS-tracked files
-
-## Task
-
-Create an automated asset processing pipeline with optimization, validation, platform-specific delivery, and real-time monitoring for game development workflows.
-
-## Asset Pipeline Components
-
-### 1. Asset Import & Validation
-- Automated asset format validation and standardization
-- Quality assurance checks for texture resolution, model complexity
-- Asset naming convention enforcement
-- Metadata extraction and tagging system
-- Source asset backup and version control integration
-
-### 2. Multi-Platform Optimization
-- Platform-specific texture compression (ASTC, DXT, etc.)
-- Model LOD generation and optimization
-- Audio format conversion and compression
-- Shader variant compilation for target platforms
-- Memory budget validation per platform
-
-### 3. Build Integration
-- Automated asset processing during build pipeline
-- Incremental processing for modified assets only
-- Asset bundle generation and packaging
-- Dependency tracking and resolution
-- Build-time asset validation and error reporting
-
-### 4. Quality Assurance
-- Visual diff comparison for texture changes
-- Model geometry validation and optimization
-- Audio quality and compression ratio analysis
-- Performance impact assessment for new assets
-- Automated regression testing for asset changes
-
-## Processing Workflows
-
-### Texture Processing Pipeline
-- Import validation and format standardization
-- Automatic mipmap generation and optimization
-- Platform-specific compression with quality settings
-- Memory usage estimation and optimization
-- Integration with sprite atlasing and texture streaming
-
-### 3D Model Processing Pipeline
-- Import validation and mesh optimization
-- Automatic LOD generation with configurable reduction ratios
-- Bone and animation optimization
-- Texture coordinate validation and optimization
-- Collision mesh generation and validation
-
-### Audio Processing Pipeline
-- Format standardization and quality validation
-- Platform-specific compression with bitrate optimization
-- Audio asset tagging and categorization
-- Streaming vs. loaded-in-memory recommendations
-- Audio occlusion and spatialization preparation
-
-### Animation Processing Pipeline
-- Animation clip optimization and compression
-- Keyframe reduction and smoothing
-- Bone hierarchy validation and optimization
-- Animation event validation and documentation
-- Runtime performance impact analysis
-
-## Deliverables
-
-1. **Asset Processing Configuration**
-   - Platform-specific processing rules and settings
-   - Quality thresholds and validation criteria
-   - Automated workflow triggers and conditions
-
-2. **Pipeline Implementation**
-   - Asset processing scripts and automation tools
-   - Build system integration and deployment
-   - Version control hooks and asset tracking
-
-3. **Monitoring & Reporting**
-   - Asset processing performance metrics
-   - Quality assurance reports and validation results
-   - Platform compatibility and optimization reports
-
-4. **Documentation & Guidelines**
-   - Asset creation guidelines for artists and designers
-   - Pipeline usage documentation and troubleshooting
-   - Performance impact guidelines and best practices
-
-## Integration Guidelines
-
-Implement pipeline with game engine-specific optimizations and industry standard tools. Ensure scalability for team collaboration and automated deployment workflows.

package/components/commands/game-development/game-performance-profiler.md

@@ -1,78 +0,0 @@
----
-allowed-tools: Read, Write, Edit, Bash
-argument-hint: [profile-type] | --fps | --memory | --rendering | --comprehensive
-description: Use PROACTIVELY to analyze game performance bottlenecks and generate optimization recommendations across multiple platforms
-model: sonnet
----
-
-# Game Performance Analysis & Optimization
-
-Analyze game performance and generate optimization recommendations: $ARGUMENTS
-
-## Current Performance Context
-
-- Game engine: @package.json or detect Unity/Unreal/Godot project files
-- Platform targets: !`find . -name "*.pbxproj" -o -name "*.gradle" -o -name "*.vcxproj" | head -3`
-- Asset pipeline: !`find . -name "*.meta" -o -name "*.asset" | wc -l` game assets
-- Build configs: !`grep -r "BuildTarget\|Platform" . 2>/dev/null | wc -l` platform configurations
-- Performance logs: !`find . -name "*profile*" -o -name "*perf*" | head -5`
-
-## Task
-
-Create comprehensive performance analysis with automated bottleneck detection, optimization suggestions, and platform-specific recommendations for game development projects.
-
-## Performance Analysis Areas
-
-### 1. Frame Rate & Rendering Performance
-- Analyze draw calls and batching efficiency
-- Identify overdraw and fillrate bottlenecks
-- Review shader complexity and optimization opportunities
-- Evaluate mesh and texture optimization potential
-- Check lighting and shadow rendering performance
-
-### 2. Memory Usage Analysis
-- Memory allocation patterns and potential leaks
-- Texture memory usage and compression opportunities
-- Audio memory optimization suggestions
-- Object pooling and garbage collection analysis
-- Platform-specific memory constraints evaluation
-
-### 3. CPU Performance Profiling
-- Script execution bottlenecks identification
-- Physics simulation optimization opportunities
-- AI and pathfinding performance analysis
-- Animation system efficiency review
-- Threading and parallelization recommendations
-
-### 4. Platform-Specific Optimization
-- Mobile performance considerations (battery, thermal throttling)
-- Console-specific optimization guidelines
-- PC hardware scaling recommendations
-- VR performance requirements and optimizations
-- Web/WebGL specific performance considerations
-
-## Deliverables
-
-1. **Performance Audit Report**
-   - Current performance metrics and benchmarks
-   - Identified bottlenecks with severity ratings
-   - Platform-specific performance analysis
-
-2. **Optimization Recommendations**
-   - Prioritized optimization suggestions
-   - Implementation difficulty and impact assessment
-   - Code and asset optimization guidelines
-
-3. **Monitoring Setup**
-   - Performance monitoring implementation
-   - Key metrics tracking configuration
-   - Automated performance regression detection
-
-4. **Testing Strategy**
-   - Performance testing procedures
-   - Target device testing recommendations
-   - Continuous performance monitoring setup
-
-## Implementation Guidelines
-
-Follow game engine best practices and target platform requirements. Generate actionable recommendations with clear implementation steps and expected performance improvements.

package/components/commands/game-development/game-testing-framework.md

@@ -1,112 +0,0 @@
----
-allowed-tools: Read, Write, Edit, Bash
-argument-hint: [test-type] | --unit | --integration | --performance | --automation | --comprehensive
-description: Use PROACTIVELY to implement comprehensive game testing frameworks with automated validation, performance testing, and multi-platform verification
-model: sonnet
----
-
-# Game Testing Framework & Automation
-
-Implement comprehensive game testing framework: $ARGUMENTS
-
-## Current Testing Context
-
-- Game engine: @package.json or detect Unity/Unreal/Godot project files
-- Existing tests: !`find . -name "*test*" -o -name "*Test*" | head -10`
-- CI/CD setup: @.github/workflows/ or @.gitlab-ci.yml or @Jenkinsfile (if exists)
-- Build configs: !`find . -name "*.sln" -o -name "*.csproj" -o -name "build.gradle" | head -3`
-- Platform targets: !`grep -r "BuildTarget\|Platform\|Target" . 2>/dev/null | wc -l` target configurations
-
-## Task
-
-Create a comprehensive testing framework for game development with automated validation, performance benchmarks, cross-platform testing, and continuous integration.
-
-## Testing Framework Components
-
-### 1. Unit Testing Infrastructure
-- Core game logic and mechanics testing
-- Component-based testing for modular systems
-- Mock and stub systems for external dependencies
-- Data validation and serialization testing
-- Mathematical calculations and algorithm verification
-
-### 2. Integration Testing Suite
-- Scene loading and transition testing
-- Asset loading and management validation
-- Save/load system integrity testing
-- Networking and multiplayer functionality
-- Platform-specific feature integration testing
-
-### 3. Performance & Benchmarking
-- Frame rate stability testing across scenarios
-- Memory usage profiling and leak detection
-- Loading time benchmarks for different content
-- Stress testing with high entity counts
-- Platform-specific performance validation
-
-### 4. Automated Gameplay Testing
-- AI behavior validation and regression testing
-- User input simulation and response verification
-- Game state progression and checkpoint validation
-- Balance testing for game mechanics
-- Procedural content generation validation
-
-## Testing Categories
-
-### Functional Testing
-- Core gameplay mechanics validation
-- User interface responsiveness and functionality
-- Audio system integration and spatial audio
-- Physics simulation accuracy and stability
-- Animation system timing and blending
-
-### Compatibility Testing
-- Multi-platform build verification
-- Device-specific feature testing (mobile, console, VR)
-- Different screen resolutions and aspect ratios
-- Hardware capability scaling and adaptation
-- Operating system compatibility validation
-
-### Regression Testing
-- Automated testing for code changes impact
-- Asset modification impact on game performance
-- Save file compatibility across versions
-- Feature functionality preservation
-- Performance regression detection
-
-### User Experience Testing
-- Accessibility features validation
-- Control scheme testing across input devices
-- Localization and internationalization testing
-- Tutorial and onboarding flow validation
-- Error handling and recovery testing
-
-## Deliverables
-
-1. **Testing Framework Setup**
-   - Test runner configuration and automation
-   - Mock systems and test data generation
-   - Continuous integration pipeline integration
-   - Test reporting and metrics collection
-
-2. **Test Suite Implementation**
-   - Unit tests for core game systems
-   - Integration tests for complex interactions
-   - Performance benchmarks and monitoring
-   - Automated gameplay validation scripts
-
-3. **Platform Testing Strategy**
-   - Device-specific test configurations
-   - Cloud testing and device farm integration
-   - Performance validation across target platforms
-   - Compatibility testing automation
-
-4. **Monitoring & Reporting**
-   - Test results dashboard and visualization
-   - Performance regression tracking
-   - Code coverage analysis and reporting
-   - Automated test failure investigation
-
-## Implementation Guidelines
-
-Integrate with game engine testing tools and establish CI/CD pipelines for automated testing. Ensure scalable test architecture that grows with project complexity and team size.