appiq-solution 1.6.4 → 1.7.0

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!**

package/docs/enhanced_prd_template.md

@@ -0,0 +1,202 @@
+# {Feature Name} PRD
+
+## Overview
+Brief description of the feature
+
+## Implementation Paths
+> Specify where this feature should be implemented. If not specified, Architect will determine optimal location.
+
+### Suggested File Structure
+```
+lib/
+├── features/
+│   └── {feature_name}/           # ← Main feature folder
+│       ├── data/
+│       │   ├── datasources/
+│       │   │   └── {feature}_remote_datasource.dart
+│       │   ├── models/
+│       │   │   └── {feature}_model.dart
+│       │   └── repositories/
+│       │       └── {feature}_repository_impl.dart
+│       ├── domain/
+│       │   ├── entities/
+│       │   │   └── {feature}_entity.dart
+│       │   ├── repositories/
+│       │   │   └── {feature}_repository.dart
+│       │   └── usecases/
+│       │       ├── get_{feature}_usecase.dart
+│       │       └── create_{feature}_usecase.dart
+│       └── presentation/
+│           ├── cubit/
+│           │   ├── {feature}_cubit.dart
+│           │   └── {feature}_state.dart
+│           ├── pages/
+│           │   └── {feature}_page.dart
+│           └── widgets/
+│               └── {feature}_widget.dart
+```
+
+### Integration Points
+> Specify existing files/classes to integrate with:
+
+- **Existing Pages**: `lib/features/home/presentation/pages/home_page.dart`
+- **Shared Services**: `lib/shared/services/api_service.dart`
+- **Common Widgets**: `lib/shared/widgets/custom_button.dart`
+- **Routing**: `lib/core/routing/app_router.dart`
+- **DI Container**: `lib/core/di/injection_container.dart`
+
+### Code Reuse Analysis
+> List existing components that should be checked/reused:
+
+#### Existing Similar Features
+- [ ] Check `lib/features/user_profile/` for similar patterns
+- [ ] Review `lib/features/authentication/` for auth integration
+- [ ] Analyze `lib/shared/widgets/` for reusable UI components
+
+#### Shared Components to Reuse
+- [ ] `lib/shared/widgets/loading_widget.dart` - For loading states
+- [ ] `lib/shared/widgets/error_widget.dart` - For error handling
+- [ ] `lib/shared/services/navigation_service.dart` - For navigation
+- [ ] `lib/shared/utils/validators.dart` - For input validation
+
+#### Common Patterns to Follow
+- [ ] Follow existing Cubit naming: `{Feature}Cubit`, `{Feature}State`
+- [ ] Use existing error handling: `Failure` classes in `lib/core/error/`
+- [ ] Follow existing API patterns: `ApiResponse<T>` wrapper
+- [ ] Use existing dependency injection patterns
+
+## UI References
+> Include mockups, wireframes, or reference images
+
+### Design Assets Location
+```
+assets/
+├── images/
+│   └── {feature_name}/
+│       ├── mockup_main_screen.png
+│       ├── wireframe_flow.png
+│       └── ui_components_reference.png
+└── icons/
+    └── {feature_name}/
+        ├── feature_icon.svg
+        └── action_icons/
+```
+
+### UI Reference Links
+- **Figma Design**: [Link to Figma prototype]
+- **Design System**: [Link to design system/style guide]
+- **Similar UI Patterns**: `lib/features/existing_feature/presentation/pages/` for reference
+
+### Visual Guidelines
+- **Theme**: Follow existing `lib/shared/theme/app_theme.dart`
+- **Colors**: Use existing color palette from `AppColors`
+- **Typography**: Follow `AppTextStyles` definitions
+- **Spacing**: Use `AppSpacing` constants
+- **Components**: Extend existing `lib/shared/widgets/` where possible
+
+## Features
+- Feature 1: Description
+- Feature 2: Description  
+- Feature 3: Description
+
+## Acceptance Criteria
+### Feature 1
+- [ ] Criteria 1
+- [ ] Criteria 2
+
+## Technical Requirements
+
+### Architecture Compliance
+- [ ] Follow Clean Architecture pattern
+- [ ] Use existing Cubit state management patterns
+- [ ] Implement Repository pattern following existing conventions
+- [ ] Use GetIt dependency injection like other features
+
+### Code Integration Requirements
+- [ ] **Before creating new files**: Check if similar functionality exists
+- [ ] **Before new widgets**: Review `lib/shared/widgets/` for reusable components
+- [ ] **Before new services**: Check `lib/shared/services/` for existing solutions
+- [ ] **Before new utilities**: Review `lib/shared/utils/` for helper functions
+
+### Performance Requirements
+- [ ] Reuse existing cached data where applicable
+- [ ] Follow existing image loading/caching patterns
+- [ ] Use existing performance monitoring setup
+
+## Auto-Analysis Instructions
+> Instructions for the auto-detect system
+
+### Code Analysis Tasks
+1. **Scan Existing Codebase**:
+   ```bash
+   # Analyze similar features
+   find lib/features/ -name "*{similar_keyword}*" -type f
+   
+   # Check shared components
+   ls -la lib/shared/widgets/ | grep -i {relevant_widgets}
+   
+   # Review existing services
+   find lib/shared/services/ -name "*{service_type}*"
+   ```
+
+2. **Dependency Analysis**:
+   - Check `pubspec.yaml` for existing packages that could be reused
+   - Review `lib/core/di/injection_container.dart` for existing service registrations
+   - Analyze existing API endpoints in data sources
+
+3. **Pattern Analysis**:
+   - Review existing Cubit implementations for state management patterns
+   - Check existing repository implementations for data access patterns
+   - Analyze existing widget compositions for UI patterns
+
+### Architect Fallback Rules
+> If implementation paths are not specified:
+
+1. **Analyze Feature Complexity**:
+   - Simple feature → Integrate into existing feature folder
+   - Complex feature → Create new feature folder
+   - Cross-cutting concern → Add to shared/
+
+2. **Check Dependencies**:
+   - Heavy external dependencies → Separate feature
+   - Uses existing services → Integrate with existing structure
+   - New infrastructure needed → Consult with data layer architecture
+
+3. **UI Complexity Assessment**:
+   - Single screen → Add to existing feature
+   - Multiple screens with navigation → New feature folder
+   - Shared UI components → Extract to shared/widgets/
+
+## User Stories
+### Epic: {Epic Name}
+- As a user I want to... so that...
+- As a user I want to... so that...
+
+## Dependencies
+- Backend API endpoints
+- Third-party integrations  
+- Design assets
+- Existing code dependencies
+
+## Migration/Integration Notes
+> Special considerations for integrating with existing codebase
+
+### Database Changes
+- [ ] Check if existing database schema can be extended
+- [ ] Review existing migration patterns
+- [ ] Consider data migration requirements
+
+### API Changes  
+- [ ] Review existing API client setup
+- [ ] Check if new endpoints fit existing patterns
+- [ ] Consider backwards compatibility
+
+### Navigation Changes
+- [ ] Review existing routing structure
+- [ ] Check if new routes fit existing patterns
+- [ ] Consider deep linking requirements
+
+### State Management Integration
+- [ ] Review existing global state management
+- [ ] Check if feature state needs to be shared
+- [ ] Consider state persistence requirements

package/docs/livestream_prd_example.md

@@ -0,0 +1,93 @@
+# Livestream Feature PRD
+
+## Overview
+Implementierung einer Live-Streaming-Funktionalität in die bestehende Flutter-App, die es Benutzern ermöglicht, Live-Videos zu streamen und zu konsumieren.
+
+## Features
+- **Live Stream Starten**: Benutzer können einen Live-Stream über die Kamera starten
+- **Stream Viewer**: Andere Benutzer können Live-Streams ansehen
+- **Chat Integration**: Real-time Chat während des Streams
+- **Stream Controls**: Play/Pause, Qualitätseinstellungen, Vollbild
+- **Stream Discovery**: Liste aktiver Streams
+- **Stream Analytics**: Viewer-Zahlen, Stream-Dauer
+
+## Acceptance Criteria
+
+### Live Stream Starten
+- [ ] Benutzer kann über einen "Go Live" Button einen Stream starten
+- [ ] Kamera-Berechtigung wird angefordert und verwaltet
+- [ ] Stream-Titel und Beschreibung können eingegeben werden
+- [ ] Stream-Qualität kann ausgewählt werden (720p, 1080p)
+- [ ] Stream kann jederzeit beendet werden
+
+### Stream Viewer
+- [ ] Liste aller aktiven Streams wird angezeigt
+- [ ] Stream kann durch Tippen geöffnet werden
+- [ ] Video-Player mit Standard-Controls (Play/Pause, Lautstärke)
+- [ ] Fullscreen-Modus verfügbar
+- [ ] Viewer-Anzahl wird angezeigt
+
+### Chat Integration
+- [ ] Chat-Interface neben/unter dem Video
+- [ ] Nachrichten werden in Echtzeit angezeigt
+- [ ] Benutzer können Nachrichten senden
+- [ ] Chat-Moderation (Nachrichten löschen)
+- [ ] Emoji-Support im Chat
+
+## Technical Requirements
+
+### Flutter Architecture
+- Clean Architecture mit Domain/Data/Presentation Layers
+- Cubit für State Management
+- Repository Pattern für Data Access
+- Dependency Injection mit GetIt
+
+### Backend Integration
+- WebRTC für Live-Streaming
+- WebSocket für Real-time Chat
+- REST API für Stream-Metadaten
+- Firebase/Supabase für User Management
+
+### Performance
+- Adaptive Bitrate Streaming
+- Efficient Memory Management
+- Background Processing für Chat
+- Caching für Stream-Thumbnails
+
+## User Stories
+
+### Epic: Live Streaming Core
+- Als Content Creator möchte ich einen Live-Stream starten können, damit ich meine Inhalte in Echtzeit teilen kann
+- Als Viewer möchte ich aktive Streams entdecken können, damit ich interessante Inhalte finden kann
+- Als Viewer möchte ich Streams in hoher Qualität ansehen können, damit ich ein gutes Seherlebnis habe
+
+### Epic: Chat & Interaction
+- Als Viewer möchte ich während des Streams chatten können, damit ich mit dem Creator und anderen Viewern interagieren kann
+- Als Content Creator möchte ich Chat-Nachrichten moderieren können, damit ich eine positive Community-Atmosphäre schaffe
+- Als Benutzer möchte ich Emojis im Chat verwenden können, damit ich meine Reaktionen ausdrücken kann
+
+### Epic: Stream Management
+- Als Content Creator möchte ich meine Stream-Einstellungen anpassen können, damit ich die beste Qualität für meine Zielgruppe biete
+- Als Content Creator möchte ich Stream-Analytics einsehen können, damit ich den Erfolg meiner Streams messen kann
+- Als Benutzer möchte ich Streams als Favoriten markieren können, damit ich sie später leicht wiederfinden kann
+
+## Dependencies
+- **Backend API**: Stream-Management Endpoints
+- **WebRTC Service**: Live-Streaming Infrastructure  
+- **Chat Service**: Real-time Messaging
+- **CDN**: Video-Delivery Network
+- **Push Notifications**: Stream-Start Benachrichtigungen
+
+## Design Requirements
+- Material Design 3 Guidelines
+- Responsive Layout (Phone/Tablet)
+- Dark/Light Theme Support
+- Accessibility Compliance (WCAG 2.1)
+- Lokalisierung (DE/EN)
+
+## Testing Requirements
+- Unit Tests für alle Business Logic
+- Widget Tests für UI Components
+- Integration Tests für Stream-Flows
+- Performance Tests für Video-Streaming
+- Security Tests für User Data