appiq-solution 1.6.4 → 1.6.5

package/bmad-core/tasks/smart-auto-detect-prds.md

@@ -0,0 +1,299 @@
+# Smart Auto-Detect PRDs Task
+
+## Purpose
+Intelligently detect PRD files, analyze existing codebase, and determine optimal implementation paths while maximizing code reuse.
+
+## Usage
+```bash
+@po smart-auto-detect-prds
+```
+
+## Enhanced Process
+
+### Step 1: PRD Discovery & Analysis
+1. **Scan for PRD Files** matching patterns:
+   - `*_prd.md`
+   - `*_requirements.md` 
+   - `*_feature.md`
+
+2. **Parse PRD Content**:
+   - Extract feature name
+   - Parse implementation paths (if specified)
+   - Identify UI reference assets
+   - Extract integration points
+   - Parse code reuse requirements
+
+### Step 2: Codebase Analysis
+For each detected PRD:
+
+#### A. Existing Code Scan
+```bash
+# 1. Find similar features
+find lib/features/ -type d -name "*{feature_keyword}*"
+
+# 2. Scan shared components  
+find lib/shared/ -name "*.dart" | xargs grep -l "{relevant_keywords}"
+
+# 3. Check existing services
+find lib/shared/services/ lib/core/services/ -name "*.dart"
+
+# 4. Analyze existing patterns
+find lib/features/ -name "*_cubit.dart" -o -name "*_repository.dart" -o -name "*_usecase.dart"
+```
+
+#### B. Dependency Analysis
+```bash
+# Check pubspec.yaml for existing packages
+grep -E "(http|dio|cached_network_image|shared_preferences)" pubspec.yaml
+
+# Analyze DI container
+grep -n "registerLazySingleton\|registerFactory" lib/core/di/injection_container.dart
+
+# Check existing API endpoints
+find lib/features/*/data/datasources/ -name "*_remote_datasource.dart" -exec grep -l "http" {} \;
+```
+
+#### C. UI Component Analysis
+```bash
+# Find reusable widgets
+find lib/shared/widgets/ -name "*.dart" | sort
+
+# Check existing page structures
+find lib/features/*/presentation/pages/ -name "*.dart"
+
+# Analyze existing themes and styles
+find lib/shared/theme/ lib/core/theme/ -name "*.dart"
+```
+
+### Step 3: Smart Path Resolution
+
+#### If Implementation Paths Specified in PRD:
+1. **Validate Specified Paths**:
+   - Check if directories exist
+   - Verify no conflicts with existing files
+   - Ensure paths follow project conventions
+
+2. **Integration Point Validation**:
+   - Verify specified existing files exist
+   - Check if integration points are compatible
+   - Validate shared component references
+
+#### If No Paths Specified - Architect Mode:
+1. **Feature Complexity Analysis**:
+   ```markdown
+   Analyzing feature: {feature_name}
+   
+   Complexity Factors:
+   - [ ] Number of screens: {count}
+   - [ ] External dependencies: {list}
+   - [ ] Database changes needed: {yes/no}
+   - [ ] New API endpoints: {count}
+   - [ ] Shared state requirements: {yes/no}
+   
+   Recommendation: {simple_integration|new_feature|shared_component}
+   ```
+
+2. **Automatic Path Generation**:
+   ```bash
+   # For new features
+   mkdir -p lib/features/{feature_name}/{data,domain,presentation}
+   
+   # For simple integrations
+   # Add to existing feature folder
+   
+   # For shared components
+   mkdir -p lib/shared/{widgets,services,utils}/{feature_name}
+   ```
+
+### Step 4: Code Reuse Optimization
+
+#### Existing Component Mapping:
+```markdown
+Found Reusable Components for {feature_name}:
+
+UI Components:
+✅ lib/shared/widgets/custom_button.dart - Can be used for {action_buttons}
+✅ lib/shared/widgets/loading_widget.dart - For loading states
+❌ Need new: {specific_widget} - No existing equivalent found
+
+Services:
+✅ lib/shared/services/api_service.dart - Can be extended for {api_calls}
+✅ lib/shared/services/navigation_service.dart - For navigation
+❌ Need new: {specific_service} - No existing equivalent found
+
+Utilities:
+✅ lib/shared/utils/validators.dart - For input validation
+✅ lib/shared/utils/formatters.dart - For data formatting
+❌ Need new: {specific_utility} - No existing equivalent found
+```
+
+#### Integration Strategy:
+```markdown
+Integration Plan for {feature_name}:
+
+1. Extend Existing:
+   - {existing_cubit} → Add {new_states}
+   - {existing_repository} → Add {new_methods}
+   - {existing_service} → Add {new_functionality}
+
+2. Create New:
+   - {new_entity} → lib/features/{feature}/domain/entities/
+   - {new_usecase} → lib/features/{feature}/domain/usecases/
+   - {new_widget} → lib/features/{feature}/presentation/widgets/
+
+3. Shared Enhancements:
+   - Add {new_shared_widget} → lib/shared/widgets/
+   - Extend {existing_theme} → lib/shared/theme/
+```
+
+### Step 5: UI Reference Processing
+
+#### Asset Organization:
+```bash
+# Create asset directories if specified
+mkdir -p assets/images/{feature_name}
+mkdir -p assets/icons/{feature_name}
+
+# Validate referenced assets exist
+for asset in {ui_reference_assets}; do
+  if [[ -f "$asset" ]]; then
+    echo "✅ Found: $asset"
+  else
+    echo "❌ Missing: $asset - Please add this asset"
+  fi
+done
+```
+
+#### UI Pattern Analysis:
+```markdown
+UI Pattern Analysis for {feature_name}:
+
+Similar Existing Patterns:
+✅ {existing_feature}/presentation/pages/{page}.dart - Similar layout structure
+✅ {existing_feature}/presentation/widgets/{widget}.dart - Similar component pattern
+
+Recommended UI Approach:
+- Base Layout: Extend {existing_scaffold_pattern}
+- Components: Reuse {existing_widget_pattern}
+- Styling: Follow {existing_theme_pattern}
+- Navigation: Use {existing_navigation_pattern}
+```
+
+### Step 6: Enhanced Story Generation
+
+#### Context-Aware Stories:
+```markdown
+Generated Stories for {feature_name}:
+
+Story 1: Setup Infrastructure
+- Extend {existing_repository} with {new_methods}
+- Add {new_entity} following {existing_pattern}
+- Register dependencies in {existing_di_container}
+
+Story 2: UI Implementation  
+- Create {new_page} extending {existing_base_page}
+- Reuse {existing_shared_widgets}
+- Follow {existing_theme_patterns}
+
+Story 3: Integration
+- Connect to {existing_navigation}
+- Integrate with {existing_services}
+- Add to {existing_routing}
+```
+
+### Step 7: Architect Consultation
+
+#### When Architect Input Needed:
+```bash
+@architect analyze-implementation-strategy {feature_name}
+```
+
+**Triggers for Architect Consultation**:
+- Complex cross-feature dependencies detected
+- No clear existing patterns found
+- Conflicting implementation approaches possible
+- Major architectural changes suggested
+
+#### Architect Analysis Output:
+```markdown
+Architect Analysis for {feature_name}:
+
+Current Architecture Assessment:
+- Existing patterns: {list}
+- Architectural constraints: {list}
+- Integration challenges: {list}
+
+Recommended Approach:
+1. Implementation Strategy: {detailed_strategy}
+2. File Structure: {recommended_structure}
+3. Integration Points: {specific_integration_points}
+4. Risk Mitigation: {potential_issues_and_solutions}
+
+Code Reuse Opportunities:
+- {existing_component} can be extended for {new_functionality}
+- {existing_pattern} should be followed for consistency
+- {existing_service} can be enhanced with {new_methods}
+```
+
+## Example Enhanced Workflow
+
+### Input: `livestream_prd.md` with Implementation Paths
+```markdown
+## Implementation Paths
+### Suggested File Structure
+lib/features/livestream/...
+
+### Integration Points  
+- Existing Pages: lib/features/home/presentation/pages/home_page.dart
+- Shared Services: lib/shared/services/api_service.dart
+
+### UI References
+assets/images/livestream/mockup_main_screen.png
+```
+
+### Auto-Analysis Output:
+```markdown
+🔍 Analyzing livestream_prd.md...
+
+📁 Path Analysis:
+✅ lib/features/livestream/ - Path available
+✅ Integration with home_page.dart - Compatible
+✅ api_service.dart - Can be extended
+
+🔍 Codebase Scan Results:
+Found Similar Features:
+- lib/features/video_player/ - 67% similarity
+- lib/features/chat/ - 45% similarity
+
+Reusable Components:
+✅ lib/shared/widgets/video_controller.dart - Perfect for stream controls
+✅ lib/shared/services/websocket_service.dart - Can handle chat
+❌ Need new: Stream management service
+
+📱 UI Analysis:
+✅ Found: assets/images/livestream/mockup_main_screen.png
+✅ Existing video player patterns can be extended
+✅ Chat UI patterns exist in lib/features/chat/
+
+🚀 Generated Implementation Plan:
+1. Extend existing video_player patterns
+2. Reuse chat UI components  
+3. Create new stream management service
+4. Integrate with existing navigation
+
+Ready for development! 
+```
+
+## Configuration
+
+Enable in `core-config.yaml`:
+```yaml
+smartAnalysis:
+  enabled: true
+  codebaseAnalysis: true
+  architectConsultation: true
+  uiReferenceProcessing: true
+  reuseOptimization: true
+```
+
+This creates an intelligent system that maximizes code reuse and ensures optimal implementation paths! 🧠✨

package/bmad-core/tasks/validate-mandatory-rules.md

@@ -0,0 +1,322 @@
+# Validate Mandatory Development Rules Task
+
+## Purpose
+Automatically validate that ALL mandatory development rules are being followed during development. This task MUST be run before any code is considered complete.
+
+## Usage
+```bash
+@dev validate-mandatory-rules
+@qa validate-mandatory-rules
+```
+
+## MANDATORY Validation Checklist
+
+### 🚨 CRITICAL: Standard Workflow Validation
+- [ ] **Plan Created**: `tasks/todo.md` exists with detailed, checkable items
+- [ ] **Plan Verified**: User has approved the plan before coding started
+- [ ] **Existing Code Checked**: Similar functionality was analyzed FIRST
+- [ ] **Todo Items Tracked**: Items are being marked complete as work progresses
+- [ ] **Explanations Provided**: High-level explanations given at each step
+- [ ] **Simple Changes**: Minimal code impact - no massive refactors
+- [ ] **Review Section Added**: Summary of changes in `todo.md`
+- [ ] **Git Commits Made**: Proper commits after each completed task
+
+### 🎯 MANDATORY: Quality Gates Validation (ALL 5 MUST PASS!)
+
+#### 1. 🧹 DRY (Don't Repeat Yourself)
+```bash
+# Check for code duplication
+find lib/ -name "*.dart" -exec grep -l "similar_pattern" {} \;
+
+# Validate no duplicate widgets
+find lib/shared/widgets/ -name "*.dart"
+find lib/features/*/presentation/widgets/ -name "*similar*"
+
+# Check for duplicate services
+find lib/shared/services/ -name "*.dart"
+find lib/features/*/data/datasources/ -name "*similar*"
+```
+
+**Validation Rules:**
+- [ ] **No duplicate widgets** when shared widget exists
+- [ ] **No duplicate services** when shared service exists
+- [ ] **No duplicate utilities** when shared utility exists
+- [ ] **No duplicate business logic** across features
+- [ ] **Common functionality extracted** to shared components
+
+#### 2. 📖 Readable
+```bash
+# Check for clear naming
+grep -r "data\|info\|manager\|handler" lib/ --include="*.dart"
+
+# Check method length (max 20 lines)
+find lib/ -name "*.dart" -exec awk '/^[[:space:]]*[a-zA-Z].*{/{flag=1; count=0} flag{count++} /^[[:space:]]*}$/{if(flag && count>20) print FILENAME":"NR-count+1"-"NR; flag=0}' {} \;
+
+# Check for comments explaining WHY
+grep -r "// TODO\|// FIXME\|// HACK" lib/ --include="*.dart"
+```
+
+**Validation Rules:**
+- [ ] **Method names** are descriptive and clear
+- [ ] **Class names** follow single responsibility principle
+- [ ] **Variable names** are self-documenting
+- [ ] **Methods are small** (max 20 lines)
+- [ ] **Comments explain WHY**, not WHAT
+
+#### 3. 🔧 Maintainable
+```bash
+# Check Clean Architecture compliance
+find lib/features/ -type d -name "data"
+find lib/features/ -type d -name "domain" 
+find lib/features/ -type d -name "presentation"
+
+# Check dependency injection usage
+grep -r "@injectable\|GetIt" lib/ --include="*.dart"
+
+# Check proper imports (no cross-layer dependencies)
+grep -r "import.*data.*" lib/features/*/domain/ --include="*.dart"
+grep -r "import.*presentation.*" lib/features/*/domain/ --include="*.dart"
+```
+
+**Validation Rules:**
+- [ ] **Clean Architecture layers** properly separated
+- [ ] **No cross-layer dependencies** (domain doesn't import data/presentation)
+- [ ] **Dependency injection** used consistently
+- [ ] **Modular design** with clear boundaries
+- [ ] **Single responsibility** principle followed
+
+#### 4. ⚡ Performant
+```bash
+# Check for redundant API calls
+grep -r "http\|api" lib/ --include="*.dart" | grep -v "test"
+
+# Check for proper const constructors
+grep -r "const.*(" lib/features/*/presentation/widgets/ --include="*.dart"
+
+# Check for efficient list operations
+grep -r "\.map(\|\.where(\|\.forEach(" lib/ --include="*.dart"
+```
+
+**Validation Rules:**
+- [ ] **No redundant API calls** in repositories
+- [ ] **Const constructors** used in widgets
+- [ ] **Efficient algorithms** implemented
+- [ ] **Proper caching** strategies used
+- [ ] **Resource optimization** applied
+
+#### 5. 🧪 Testable
+```bash
+# Check for unit tests
+find test/ -name "*_test.dart" | wc -l
+find lib/features/*/domain/usecases/ -name "*.dart" | wc -l
+
+# Check for widget tests
+find test/ -name "*_widget_test.dart" | wc -l
+find lib/features/*/presentation/widgets/ -name "*.dart" | wc -l
+
+# Check test coverage
+flutter test --coverage
+```
+
+**Validation Rules:**
+- [ ] **Unit tests** exist for all use cases
+- [ ] **Widget tests** exist for all custom widgets
+- [ ] **Repository tests** with proper mocking
+- [ ] **Cubit tests** for all state management
+- [ ] **Test coverage** meets minimum requirements (80%+)
+
+### 📱 MANDATORY: Flutter-Specific Validation
+
+#### Clean Architecture Compliance
+```bash
+# Validate folder structure
+ls -la lib/features/*/data/datasources/
+ls -la lib/features/*/data/models/
+ls -la lib/features/*/data/repositories/
+ls -la lib/features/*/domain/entities/
+ls -la lib/features/*/domain/repositories/
+ls -la lib/features/*/domain/usecases/
+ls -la lib/features/*/presentation/cubit/
+ls -la lib/features/*/presentation/pages/
+ls -la lib/features/*/presentation/widgets/
+```
+
+**Validation Rules:**
+- [ ] **Proper folder structure** following Clean Architecture
+- [ ] **Entity classes** in domain layer
+- [ ] **Model classes** in data layer with JSON serialization
+- [ ] **Repository interfaces** in domain, implementations in data
+- [ ] **Use cases** contain business logic
+- [ ] **Cubits** handle state management
+- [ ] **Pages and widgets** in presentation layer
+
+#### Localization Compliance
+```bash
+# Check for static text (INSTANT FAILURE!)
+grep -r "Text(\|text:\|title:\|label:" lib/features/ --include="*.dart" | grep -v "AppLocalizations\|context.l10n\|S.of"
+
+# Check for localization usage
+grep -r "AppLocalizations.of\|context.l10n\|S.of" lib/ --include="*.dart"
+
+# Validate ARB files
+find lib/l10n/ -name "*.arb"
+```
+
+**Validation Rules:**
+- [ ] **NO static text** in any widget (INSTANT FAILURE if found!)
+- [ ] **All text uses AppLocalizations** or equivalent
+- [ ] **ARB files** contain all required keys
+- [ ] **Localization keys** are descriptive and hierarchical
+- [ ] **Placeholders** used for dynamic content
+
+#### State Management Compliance
+```bash
+# Check Cubit usage
+find lib/features/*/presentation/cubit/ -name "*_cubit.dart"
+find lib/features/*/presentation/cubit/ -name "*_state.dart"
+
+# Check for proper state classes
+grep -r "extends Equatable" lib/features/*/presentation/cubit/ --include="*.dart"
+grep -r "copyWith" lib/features/*/presentation/cubit/ --include="*.dart"
+```
+
+**Validation Rules:**
+- [ ] **Cubit pattern** used for state management
+- [ ] **State classes** extend Equatable
+- [ ] **CopyWith methods** implemented
+- [ ] **Proper state transitions** defined
+- [ ] **Error handling** in state management
+
+### 🔍 MANDATORY: Code Integration Validation
+
+#### Existing Component Check
+```bash
+# Before creating new widgets
+echo "Checking existing widgets..."
+find lib/shared/widgets/ -name "*.dart" | sort
+
+# Before creating new services  
+echo "Checking existing services..."
+find lib/shared/services/ -name "*.dart" | sort
+
+# Before creating new utilities
+echo "Checking existing utilities..."
+find lib/shared/utils/ -name "*.dart" | sort
+```
+
+**Validation Rules:**
+- [ ] **Existing widgets checked** before creating new ones
+- [ ] **Existing services checked** before creating new ones
+- [ ] **Existing utilities checked** before creating new ones
+- [ ] **Similar features analyzed** for reusable patterns
+- [ ] **Integration points identified** and utilized
+
+#### Pattern Consistency Check
+```bash
+# Check naming conventions
+find lib/ -name "*.dart" | grep -v "snake_case"
+find lib/ -name "*.dart" -exec basename {} \; | grep -E "[A-Z]"
+
+# Check class naming
+grep -r "^class [a-z]" lib/ --include="*.dart"
+grep -r "^class.*[_-]" lib/ --include="*.dart"
+```
+
+**Validation Rules:**
+- [ ] **File names** use snake_case
+- [ ] **Class names** use PascalCase  
+- [ ] **Method names** use camelCase
+- [ ] **Variable names** use camelCase
+- [ ] **Constants** use SCREAMING_SNAKE_CASE
+
+### 🚨 FAILURE CONDITIONS (INSTANT FAILURE!)
+
+#### Critical Failures (Development STOPS immediately!)
+```bash
+# Check for static text (INSTANT FAILURE!)
+if grep -r "Text('\|Text(\"\|title: '\|title: \"" lib/features/ --include="*.dart" | grep -v "AppLocalizations\|context.l10n\|S.of"; then
+    echo "❌ INSTANT FAILURE: Static text found in UI!"
+    exit 1
+fi
+
+# Check for code duplication (INSTANT FAILURE!)
+if find lib/features/ -name "*.dart" -exec grep -l "duplicate_pattern" {} \; 2>/dev/null; then
+    echo "❌ INSTANT FAILURE: Code duplication detected!"
+    exit 1
+fi
+
+# Check for architecture violations (INSTANT FAILURE!)
+if grep -r "import.*data.*" lib/features/*/domain/ --include="*.dart" 2>/dev/null; then
+    echo "❌ INSTANT FAILURE: Domain layer importing data layer!"
+    exit 1
+fi
+
+# Check for missing tests (INSTANT FAILURE!)
+if [ $(find test/ -name "*_test.dart" | wc -l) -eq 0 ]; then
+    echo "❌ INSTANT FAILURE: No tests found!"
+    exit 1
+fi
+```
+
+## Validation Report Generation
+
+### Success Report
+```markdown
+✅ MANDATORY RULES VALIDATION PASSED!
+
+Standard Workflow: ✅ PASSED
+- Plan created and verified
+- Existing code checked first
+- Simple changes implemented
+- Review section completed
+
+Quality Gates: ✅ ALL 5 PASSED
+- 🧹 DRY: No code duplication
+- 📖 Readable: Clear, self-documenting code
+- 🔧 Maintainable: Clean Architecture followed
+- ⚡ Performant: Optimized implementation
+- 🧪 Testable: Comprehensive test coverage
+
+Flutter Compliance: ✅ PASSED
+- Clean Architecture structure
+- No static text found
+- Proper Cubit state management
+- Localization fully implemented
+
+Code Integration: ✅ PASSED
+- Existing components reused
+- Patterns followed consistently
+- No unnecessary duplication
+
+🎉 READY FOR PRODUCTION!
+```
+
+### Failure Report
+```markdown
+❌ MANDATORY RULES VALIDATION FAILED!
+
+Critical Failures:
+❌ Static text found in lib/features/livestream/presentation/pages/stream_page.dart:45
+❌ Code duplication detected in lib/features/livestream/presentation/widgets/
+❌ Missing tests for StreamUseCase
+
+DEVELOPMENT MUST STOP UNTIL FIXED!
+
+Required Actions:
+1. Replace all static text with AppLocalizations
+2. Remove duplicate code and reuse existing components
+3. Add comprehensive unit tests
+4. Re-run validation
+
+DO NOT PROCEED UNTIL ALL FAILURES ARE RESOLVED!
+```
+
+## Integration with Development Workflow
+
+This validation MUST be run:
+- [ ] **Before any code review**
+- [ ] **Before any git commit**
+- [ ] **Before marking any story as complete**
+- [ ] **Before any deployment**
+
+**NO EXCEPTIONS! NO SHORTCUTS! NO COMPROMISES!**