appiq-solution 1.2.0 → 1.3.0

package/flutter/punkt.claude/punkt.claude/commands/checkdev.md

@@ -0,0 +1,122 @@
+# /checkdev Command - Development Quality Checker
+
+Du bist ein Quality Assurance Assistant für das AiGo Mobile App Projekt. Deine Aufgabe ist es, completed Tasks aus `developer_check.md` zu prüfen und deren Qualität sicherzustellen.
+
+## Arbeitsweise
+
+1. **Status-Check**: Lese `developer_check.md` und identifiziere ✅ COMPLETED Tasks
+2. **Smart Analysis**: Prüfe Tasks nur wenn sie logisch vollständig sein können
+3. **Code Review**: Führe Quality-Checks für fertige Features durch
+4. **Problem-Fixing**: Behebe gefundene Issues ohne Disruption
+5. **Documentation**: Aktualisiere developer_check.md mit Review-Ergebnissen
+
+## Quality Check Kriterien
+
+### 🧹 DRY-Prinzip
+- [ ] Keine Code-Duplikation
+- [ ] Wiederverwendbare Komponenten
+- [ ] Gemeinsame Utilities genutzt
+
+### 📖 Lesbarkeit
+- [ ] Klare Variablen- und Methodennamen
+- [ ] Logische Code-Struktur
+- [ ] Angemessene Kommentierung
+
+### 🔧 Wartbarkeit  
+- [ ] Modulare Architektur
+- [ ] Lose Kopplung
+- [ ] Single Responsibility Principle
+
+### ⚡ Performance
+- [ ] Effiziente Algorithmen
+- [ ] Keine unnötigen Repository-Calls
+- [ ] Optimierte Widget-Builds
+
+### 🧪 Testbarkeit
+- [ ] Testbare Methoden-Größe
+- [ ] Dependency Injection möglich
+- [ ] Mock-freundliche Implementierung
+
+## Smart Task Analysis
+
+**Sichere Checks** (immer prüfen):
+- Standalone Komponenten
+- Utility-Funktionen  
+- UI-Widgets ohne Backend-Dependencies
+- Datenmodelle und DTOs
+
+**Bedachte Checks** (Kontext berücksichtigen):
+- Services mit Dependencies
+- Repository-Implementierungen
+- Features mit Multi-Step-Setup
+
+**Vermeiden**:
+- Prüfung von Task 1 wenn Task 2-5 von derselben Feature noch pending sind
+- Breaking von funktionierenden Systemen
+- Checks ohne vollständigen Kontext
+
+## Review-Process
+
+1. **Context Analysis**: Verstehe die Gesamtfunktion des Tasks
+2. **Dependency Check**: Prüfe ob alle Dependencies erfüllt sind  
+3. **Code Inspection**: Führe Quality-Checks durch
+4. **Error Detection**: Suche nach Compilation/Runtime-Errors
+5. **Fix Implementation**: Behebe Issues minimal-invasiv
+6. **Status Update**: Aktualisiere developer_check.md
+
+## Review Status Codes
+
+```markdown
+### Review Results
+**Reviewer**: Claude Code QA
+**Review Date**: [YYYY-MM-DD HH:MM]
+**Status**: [✅ PASSED | ⚠️ MINOR_ISSUES | ❌ FAILED]
+
+#### Quality Score: [X/5]
+- 🧹 DRY: [✅|❌]
+- 📖 Readable: [✅|❌] 
+- 🔧 Maintainable: [✅|❌]
+- ⚡ Performant: [✅|❌]
+- 🧪 Testable: [✅|❌]
+
+#### Issues Found
+- [Issue 1 - severity: high/medium/low]
+- [Issue 2 - severity: high/medium/low]
+
+#### Fixes Applied
+- [Fix 1]
+- [Fix 2]
+
+#### Recommendations
+- [Recommendation 1]
+- [Recommendation 2]
+```
+
+## Error Handling Strategy
+
+1. **Compilation Errors**: Nur fixen wenn Task isoliert abgeschlossen
+2. **Missing Dependencies**: Prüfe ob in anderen pending Tasks implementiert
+3. **Breaking Changes**: Minimal-fixes, keine großen Refactorings
+4. **Test Failures**: Fixen oder als Known Issue dokumentieren
+
+## Command Usage
+
+Der Assistant wird automatisch:
+1. developer_check.md scannen
+2. Completed Tasks identifizieren  
+3. Smart Quality-Checks durchführen
+4. Issues beheben
+5. Review-Ergebnisse dokumentieren
+6. Empfehlungen geben
+
+## Sicherheitsregeln
+
+- ❌ **Keine Breaking Changes** an funktionierenden Features
+- ❌ **Keine Checks** von abhängigen Tasks ohne Kontext
+- ❌ **Keine großen Refactorings** während Reviews
+- ✅ **Minimal-invasive Fixes** bevorzugen
+- ✅ **Context-bewusste Prüfungen** durchführen
+
+---
+
+**Quality Assurance bereit!** 🔍✨

package/flutter/punkt.claude/punkt.claude/commands/create-feature.md

@@ -0,0 +1,174 @@
+# Create Complete Feature Command - Parallel Orchestrator
+
+Orchestrates parallel feature development across multiple specialized agents using the AiGo architecture with RiverPod, Freezed, and Clean Architecture.
+
+**Usage:** `create-feature [FEATURE_NAME] [FEATURE_DESCRIPTION]`
+
+**Example:** `create-feature user-favorites "Allow users to mark places as favorites and view them in a separate list"`
+
+## ⚡ Parallel Development System
+
+This command orchestrates multiple specialized agents that work in parallel through a central communication channel. Each agent handles a specific layer while coordinating dependencies through `/Users/vapps-it/Projects/AiGo/sourceCode/mobile_app/.claude/channel.md`.
+
+## 🚀 Parallel Execution Workflow
+
+### Step 1: Initialize Channel
+```bash
+# Initialize the communication channel
+1. Update channel.md with feature details
+2. Set all layers to "NOT_STARTED" 
+3. Define feature requirements and dependencies
+4. Ensure RiverPod providers and Freezed models follow AiGo patterns
+```
+
+### Step 2: Launch Parallel Agents
+Execute these commands **simultaneously** in separate Claude conversations:
+
+#### 🏗️ Domain Layer (Independent - Start First)
+```bash
+feature-domain-layer [FEATURE_NAME] "[FEATURE_DESCRIPTION]"
+```
+- Creates domain models (pure Dart classes)
+- Defines repository interfaces
+- **No dependencies** - can start immediately
+- Uses clean domain patterns without Freezed (pure business logic)
+
+#### 🎨 UI Layer (Independent - Start First) 
+```bash
+feature-ui-layer [FEATURE_NAME] "[FEATURE_DESCRIPTION]"
+```
+- Creates screens, components, and widgets
+- Implements theming and responsive design
+- **No dependencies** - can start immediately
+
+#### 🧠 Business Logic (Coordinates with Domain)
+```bash
+feature-business-logic [FEATURE_NAME] "[FEATURE_DESCRIPTION]"
+```
+- Creates RiverPod providers with @riverpod annotations
+- Creates Freezed state classes with proper immutability
+- **Coordinates with Domain layer** through channel
+- Uses riverpod_annotation for code generation
+
+#### 💾 Data Layer (Waits for Domain)
+```bash
+feature-data-layer [FEATURE_NAME] "[FEATURE_DESCRIPTION]"
+```
+- Creates Freezed DTOs with JSON annotations
+- Creates mappers between DTOs and domain models
+- Creates repository implementations
+- **Waits for Domain layer completion** (checks channel status)
+- Auto-starts when Domain layer marks as "COMPLETED"
+
+#### 🌍 Localization (Waits for UI)
+```bash
+feature-localization [FEATURE_NAME] "[FEATURE_DESCRIPTION]"
+```
+- Adds translations for all 5 languages (en, de, ru, tr, ar)
+- **Waits for UI layer completion** (needs all text content)
+- Auto-starts when UI layer marks as "COMPLETED"
+
+#### 🔧 Integration (Waits for All)
+```bash
+feature-integration [FEATURE_NAME] "[FEATURE_DESCRIPTION]"
+```
+- Connects all layers and updates service locator
+- **Waits for ALL other layers** to complete
+- Final integration and testing phase
+
+### Step 3: Monitor Progress
+Each agent updates the channel with:
+- Current status and progress percentage
+- Files created and dependencies resolved
+- Blockers and completion notifications
+
+### Step 4: Automatic Coordination
+- **Domain completes** → Unblocks Data Layer
+- **UI completes** → Unblocks Localization  
+- **All complete** → Unblocks Integration
+- **Integration completes** → Feature ready for production
+
+## 📋 Agent Communication Protocol
+
+### Channel Status Updates
+Each agent must:
+1. **Check channel** before starting work
+2. **Update progress** regularly during development  
+3. **Mark completion** and unblock dependent layers
+4. **Report blockers** if dependencies are missing
+
+### Dependency Chain
+```
+Integration Layer (waits for all)
+    ↑
+Localization ← UI Layer (parallel start)
+    ↑           ↑
+Data Layer  ← Domain Layer (parallel start)
+    ↑           ↑
+Business Logic Layer (coordinates with both)
+```
+
+## 🎯 Execution Example
+
+For feature "project-favorites":
+
+1. **Launch simultaneously:**
+   - Agent A: `feature-domain-layer project-favorites "Favorite projects functionality"`
+   - Agent B: `feature-ui-layer project-favorites "Favorite projects functionality"`  
+   - Agent C: `feature-business-logic project-favorites "Favorite projects functionality"`
+
+2. **Auto-triggered when dependencies complete:**
+   - Agent D: `feature-data-layer` (starts when Domain completes)
+   - Agent E: `feature-localization` (starts when UI completes)
+
+3. **Final integration:**
+   - Agent F: `feature-integration` (starts when all layers complete)
+
+## ⚡ Performance Benefits
+
+- **5-6x faster development** through parallel execution
+- **Reduced waiting time** with automatic dependency resolution
+- **Consistent quality** through specialized agent expertise
+- **Real-time coordination** prevents conflicts and overwrites
+- **Automatic integration** ensures all pieces fit together perfectly
+
+## Implementation Guidelines
+
+### Code Style Requirements
+- Follow existing naming conventions exactly
+- Use identical code formatting and structure
+- Implement the same error handling patterns
+- Follow the exact file organization structure
+- Use the same design patterns throughout
+
+### Architecture Compliance
+- **Clean Architecture**: Maintain strict layer separation (Domain → Data → Presentation)
+- **RiverPod 2.0**: Use @riverpod annotations with code generation
+- **Freezed**: Use for DTOs and state classes with JSON annotations
+- **GetIt + RiverPod**: Dual DI pattern for services and UI state
+- **Service Locator**: Register new dependencies in service_locator.dart
+
+### Quality Criteria
+Every feature must meet these 5 quality criteria:
+1. **🧹 DRY-Prinzip**: No code duplication
+2. **📖 Readability**: Clean, understandable code with proper documentation
+3. **🔧 Maintainability**: Logical grouping and easy to modify
+4. **⚡ Performance**: Optimized for performance following existing patterns
+5. **🧪 Testability**: Easily testable with proper separation of concerns
+
+### Multi-language & Theme Support
+- **Localization**: All text must be in ARB files (en, de, ru, tr, ar)
+- **Dark/Light Mode**: Full support for both themes via ThemeProvider
+- **Material 3**: Consistent with existing AppTheme implementation
+- **RTL Support**: Arabic language with proper text direction
+- **Code Generation**: Use flutter gen-l10n for translations
+
+## Execution Process
+
+1. **Create TODO List**: Break down the feature into specific, trackable tasks
+2. **Follow Architecture**: Implement each layer following the exact existing patterns
+3. **Reuse Components**: Maximize reuse of existing core utilities and services
+4. **Test Thoroughly**: Verify all aspects work correctly
+5. **Document Changes**: Provide clear summary of what was implemented
+
+The end result should be a feature that looks and feels like it was built by the same developer who built the rest of the application, following identical patterns and maintaining perfect consistency with the existing codebase.

package/flutter/punkt.claude/punkt.claude/commands/dev.md

@@ -0,0 +1,79 @@
+# /dev Command - Development Task Manager
+
+Du bist ein Developer Assistant für das AiGo Mobile App Projekt. Deine Aufgabe ist es, Development-Tasks zu verwalten und umzusetzen.
+
+## Arbeitsweise
+
+1. **Task-Analyse**: Verstehe die Anforderung und erstelle einen detaillierten Plan
+2. **Status-Updates**: Aktualisiere `developer_check.md` mit allen Task-Fortschritten
+3. **Clean Code**: Befolge alle Regeln aus CLAUDE.md (DRY, Lesbarkeit, Wartbarkeit, Performance, Testbarkeit)
+4. **Konsistenz**: Folge der bestehenden Architektur und den Patterns im Codebase
+
+## Developer Check Status Management
+
+Für jeden Task:
+- ✅ COMPLETED: Task vollständig implementiert und getestet
+- 🔄 IN_PROGRESS: Aktuell in Bearbeitung
+- ⏳ PENDING: Wartet auf Bearbeitung
+- ❌ BLOCKED: Blockiert durch Abhängigkeiten/Probleme
+
+## Task-Struktur
+
+```markdown
+## [TASK_ID] - [Task Name]
+**Status**: [✅|🔄|⏳|❌]
+**Priority**: [HIGH|MEDIUM|LOW]
+**Estimated Time**: [Zeit in Stunden]
+**Dependencies**: [Abhängigkeiten falls vorhanden]
+
+### Description
+[Detaillierte Beschreibung des Tasks]
+
+### Implementation Details
+- [ ] Subtask 1
+- [ ] Subtask 2
+- [ ] Subtask 3
+
+### Files Modified
+- file1.dart
+- file2.dart
+
+### Quality Checklist
+- [ ] DRY Prinzip befolgt
+- [ ] Code lesbar und dokumentiert
+- [ ] Wartbar strukturiert
+- [ ] Performance optimiert
+- [ ] Testbar implementiert
+
+### Notes
+[Zusätzliche Notizen oder Besonderheiten]
+```
+
+## Wichtige Regeln
+
+1. **Niemals komplexe Änderungen**: Jede Änderung soll so minimal wie möglich sein
+2. **Bestehende Patterns nutzen**: Prüfe immer zuerst bestehenden Code
+3. **Documentation**: Code dokumentieren, aber nicht überdokumentieren
+4. **Testing**: Sicherstellen dass Tests pass ieren
+5. **Architektur**: Clean Architecture Layer-Trennung beachten
+
+## Nach Task-Completion
+
+1. Status auf ✅ COMPLETED setzen
+2. Git Commit mit aussagekräftiger Message erstellen
+3. Review-Section in developer_check.md aktualisieren
+4. Nächsten Task beginnen
+
+## Command Usage
+
+Gib einfach ein was implementiert werden soll und der Assistant wird:
+1. Task-Plan erstellen
+2. developer_check.md aktualisieren
+3. Implementation durchführen
+4. Status kontinuierlich updaten
+5. Quality-Check durchführen
+6. Git Commit erstellen
+
+---
+
+**Bereit für Development-Tasks!** 🚀

package/flutter/punkt.claude/punkt.claude/commands/explain-codebase.md

@@ -0,0 +1 @@
+Scan out the whole codebase and explain it to me in an easy way that allows me to understand how it functions and how everthing is connected.