appiq-solution 1.2.0 → 1.3.1

package/#Tools/APPIQ-METHOD/deployment/build/expansion-packs/bmad-mobile-app-dev/workflows/mobile-platform-selection.yaml

@@ -0,0 +1,404 @@
+workflow:
+  id: mobile-platform-selection
+  name: Mobile Platform Selection & Architecture Planning
+  description: >-
+    Comprehensive workflow for selecting optimal mobile development platform 
+    (Flutter vs React Native) and state management solution based on project 
+    requirements, team expertise, and technical constraints.
+  type: decision-making
+  project_types:
+    - mobile-app
+    - cross-platform
+    - native-app
+    - mvp
+    - enterprise-mobile
+
+  sequence:
+    - step: project_type_identification
+      agent: mobile-architect
+      action: identify_project_scope
+      creates: project-requirements-analysis.md
+      notes: |
+        Determine if this is:
+        - New mobile app (greenfield)
+        - Existing app enhancement (brownfield)
+        - Web-to-mobile expansion
+        - Platform migration project
+        
+        Key questions:
+        - Is this a new mobile app or enhancing an existing one?
+        - Do you have existing web applications to integrate with?
+        - What are your primary business goals?
+        - What is your target timeline and budget?
+
+    - step: requirements_gathering
+      agent: mobile-pm
+      action: analyze_functional_requirements
+      requires: project-requirements-analysis.md
+      creates: functional-requirements.md
+      notes: |
+        Gather detailed requirements:
+        - Core features and functionality
+        - Performance requirements
+        - Platform-specific needs (iOS/Android)
+        - Integration requirements
+        - Scalability expectations
+        - Maintenance considerations
+
+    - step: team_assessment
+      agent: mobile-architect
+      action: evaluate_team_capabilities
+      creates: team-capability-matrix.md
+      notes: |
+        Assess team expertise:
+        - Current mobile development experience
+        - JavaScript/TypeScript vs Dart proficiency
+        - React/React Native experience
+        - Flutter/Dart experience
+        - Learning capacity and timeline
+        - Team size and structure
+
+    - step: technical_constraints_analysis
+      agent: mobile-architect
+      action: analyze_technical_constraints
+      requires: 
+        - functional-requirements.md
+        - team-capability-matrix.md
+      creates: technical-constraints.md
+      notes: |
+        Evaluate technical factors:
+        - Performance requirements
+        - Platform-specific feature needs
+        - Third-party integration requirements
+        - Existing infrastructure compatibility
+        - Security and compliance needs
+        - Maintenance and update requirements
+
+    - step: platform_evaluation_matrix
+      agent: mobile-architect
+      action: create_evaluation_matrix
+      requires:
+        - functional-requirements.md
+        - team-capability-matrix.md
+        - technical-constraints.md
+      creates: platform-evaluation-matrix.md
+      notes: |
+        Create comprehensive comparison matrix:
+        
+        Evaluation Criteria:
+        - Development Speed
+        - Performance Requirements
+        - Platform-specific Features
+        - Team Learning Curve
+        - Long-term Maintenance
+        - Community & Ecosystem
+        - Third-party Integrations
+        - UI/UX Flexibility
+        - Testing Capabilities
+        - Deployment Complexity
+
+    - step: platform_recommendation
+      agent: mobile-architect
+      action: recommend_platform
+      requires: platform-evaluation-matrix.md
+      creates: platform-recommendation.md
+      notes: |
+        Provide detailed platform recommendation:
+        - Primary platform choice (Flutter or React Native)
+        - Detailed rationale for decision
+        - Trade-offs and considerations
+        - Risk assessment and mitigation
+        - Timeline implications
+        - Team training needs
+
+    - step: state_management_analysis
+      agent: mobile-architect
+      action: analyze_state_management_needs
+      requires: platform-recommendation.md
+      creates: state-management-analysis.md
+      condition: platform_selected
+      notes: |
+        Analyze state management requirements:
+        - App complexity assessment
+        - Data flow patterns
+        - Real-time requirements
+        - Offline capabilities
+        - Performance considerations
+        - Team familiarity factors
+
+    - step: state_management_recommendation
+      agent: mobile-architect
+      action: recommend_state_management
+      requires: state-management-analysis.md
+      creates: state-management-recommendation.md
+      notes: |
+        For Flutter apps, evaluate:
+        - BLoC/Cubit (Enterprise/Complex apps)
+        - Riverpod (Modern/Medium apps)
+        - GetX (Rapid development/Simple apps)
+        - Provider (Learning/Basic apps)
+        
+        For React Native apps, evaluate:
+        - Redux Toolkit (Enterprise/Complex apps)
+        - Zustand (Performance-focused/Medium apps)
+        - Context API (Simple global state)
+
+    - step: architecture_planning
+      agent: mobile-architect
+      action: design_initial_architecture
+      requires:
+        - platform-recommendation.md
+        - state-management-recommendation.md
+      creates: initial-architecture-plan.md
+      notes: |
+        Create initial architecture blueprint:
+        - Clean architecture layer design
+        - Dependency injection strategy
+        - Navigation architecture
+        - Data layer design
+        - Testing strategy outline
+        - Performance optimization plan
+
+    - step: development_guidelines_selection
+      agent: mobile-architect
+      action: select_development_guidelines
+      requires: initial-architecture-plan.md
+      creates: development-guidelines.md
+      condition: platform_selected
+      notes: |
+        Select and customize development guidelines:
+        - For Flutter: Apply flutter-development-guidelines.md
+        - For React Native: Apply react-native best practices
+        - Customize coding standards for team
+        - Define code review processes
+        - Set quality gates and metrics
+
+    - step: technology_stack_definition
+      agent: mobile-architect
+      action: define_technology_stack
+      requires:
+        - platform-recommendation.md
+        - state-management-recommendation.md
+        - development-guidelines.md
+      creates: technology-stack.md
+      notes: |
+        Define complete technology stack:
+        - Core framework and version
+        - State management solution
+        - Navigation library
+        - Network layer
+        - Local storage solution
+        - Testing frameworks
+        - CI/CD tools
+        - Development tools and IDE setup
+
+    - step: implementation_roadmap
+      agent: mobile-pm
+      action: create_implementation_roadmap
+      requires:
+        - initial-architecture-plan.md
+        - technology-stack.md
+      creates: implementation-roadmap.md
+      notes: |
+        Create detailed implementation plan:
+        - Project phases and milestones
+        - Team onboarding and training plan
+        - Risk mitigation strategies
+        - Quality assurance processes
+        - Deployment and release strategy
+        - Success metrics and KPIs
+
+    - step: stakeholder_review
+      agent: mobile-pm
+      action: prepare_stakeholder_presentation
+      requires:
+        - platform-recommendation.md
+        - implementation-roadmap.md
+      creates: stakeholder-presentation.md
+      notes: |
+        Prepare comprehensive stakeholder presentation:
+        - Executive summary of recommendations
+        - Business impact analysis
+        - Timeline and resource requirements
+        - Risk assessment
+        - Success criteria
+        - Next steps and approvals needed
+
+    - workflow_completion:
+      action: finalize_platform_selection
+      creates: platform-selection-complete.md
+      notes: |
+        Platform selection complete! Ready to proceed with:
+        1. Team setup and training
+        2. Development environment configuration
+        3. Architecture documentation
+        4. Project kickoff and first sprint planning
+
+  flow_diagram: |
+    ```mermaid
+    graph TD
+        A[Start: Mobile App Project] --> B[Project Type Identification]
+        B --> C{Project Type?}
+        
+        C -->|Greenfield| D[Requirements Gathering]
+        C -->|Brownfield| E[Existing App Analysis]
+        C -->|Migration| F[Migration Requirements]
+        
+        D --> G[Team Assessment]
+        E --> G
+        F --> G
+        
+        G --> H[Technical Constraints Analysis]
+        H --> I[Platform Evaluation Matrix]
+        
+        I --> J{Evaluation Complete?}
+        J -->|No| K[Gather More Data]
+        K --> I
+        J -->|Yes| L[Platform Recommendation]
+        
+        L --> M{Platform Selected?}
+        M -->|Flutter| N[Flutter State Management Analysis]
+        M -->|React Native| O[React Native State Management Analysis]
+        
+        N --> P[State Management Recommendation]
+        O --> P
+        
+        P --> Q[Architecture Planning]
+        Q --> R[Development Guidelines Selection]
+        R --> S[Technology Stack Definition]
+        S --> T[Implementation Roadmap]
+        T --> U[Stakeholder Review]
+        
+        U --> V{Approved?}
+        V -->|No| W[Revise Recommendations]
+        W --> U
+        V -->|Yes| X[Platform Selection Complete]
+        
+        style X fill:#90EE90
+        style L fill:#ADD8E6
+        style N fill:#FFE4B5
+        style O fill:#FFE4B5
+        style P fill:#FFE4B5
+        style Q fill:#DDA0DD
+    ```
+
+  decision_criteria:
+    flutter_selection:
+      high_performance_ui: "App requires complex animations and custom UI"
+      single_codebase_priority: "Maximum code sharing is critical"
+      dart_acceptance: "Team willing to learn Dart language"
+      google_ecosystem: "Heavy integration with Google services"
+      long_term_support: "Long-term maintenance and stability priority"
+      
+    react_native_selection:
+      javascript_expertise: "Team has strong React/JavaScript background"
+      existing_react_web: "Existing React web application to share logic"
+      third_party_integrations: "Extensive native library ecosystem needed"
+      over_the_air_updates: "CodePush-style updates are critical"
+      rapid_prototyping: "Fast time-to-market is priority"
+
+    state_management_selection:
+      flutter:
+        bloc_cubit:
+          complexity: high
+          team_size: large
+          predictability: required
+          testing: extensive
+        riverpod:
+          complexity: medium_high
+          modernization: preferred
+          type_safety: critical
+          flexibility: high
+        getx:
+          complexity: low_medium
+          speed: critical
+          simplicity: preferred
+          team_experience: beginner_intermediate
+        provider:
+          complexity: low
+          learning: true
+          understanding: fundamental
+          
+      react_native:
+        redux_toolkit:
+          complexity: high
+          debugging: advanced
+          middleware: required
+          predictability: critical
+        zustand:
+          complexity: medium
+          performance: critical
+          simplicity: preferred
+          bundle_size: small
+        context_api:
+          complexity: low
+          dependencies: minimal
+          patterns: react_native
+          scope: limited
+
+  handoff_prompts:
+    requirements_to_evaluation: |
+      Requirements analysis complete. Key findings:
+      - Project scope: {{project_scope}}
+      - Performance needs: {{performance_requirements}}
+      - Team expertise: {{team_capabilities}}
+      - Timeline: {{project_timeline}}
+      
+      Proceeding to platform evaluation matrix creation.
+      
+    evaluation_to_recommendation: |
+      Platform evaluation matrix complete. Scoring results:
+      - Flutter total score: {{flutter_score}}/{{max_score}}
+      - React Native total score: {{react_native_score}}/{{max_score}}
+      
+      Key differentiators: {{key_differentiators}}
+      Proceeding to final platform recommendation.
+      
+    platform_to_state_management: |
+      Platform selected: {{chosen_platform}}
+      Rationale: {{platform_rationale}}
+      
+      Now analyzing state management needs for {{chosen_platform}}:
+      - App complexity: {{app_complexity}}
+      - Team experience: {{team_state_management_experience}}
+      - Performance requirements: {{performance_needs}}
+      
+    state_management_to_architecture: |
+      State management solution selected: {{chosen_state_management}}
+      Rationale: {{state_management_rationale}}
+      
+      Proceeding to architecture design with:
+      - Platform: {{chosen_platform}}
+      - State Management: {{chosen_state_management}}
+      - Architecture Pattern: Clean Architecture
+      
+    architecture_to_roadmap: |
+      Initial architecture plan complete:
+      - Layer structure defined
+      - Dependency injection strategy planned
+      - Technology stack selected
+      
+      Creating implementation roadmap with phases and milestones.
+      
+    completion: |
+      Platform selection workflow complete!
+      
+      Final recommendations:
+      - Platform: {{chosen_platform}}
+      - State Management: {{chosen_state_management}}
+      - Architecture: Clean Architecture with {{specific_patterns}}
+      
+      Ready to proceed with project setup and development.
+
+  success_metrics:
+    decision_quality:
+      - Platform choice aligns with 90%+ of requirements
+      - Team confidence in technology selection > 8/10
+      - Stakeholder approval achieved
+      - Clear implementation path defined
+    
+    process_efficiency:
+      - Decision made within planned timeline
+      - All stakeholders consulted and aligned
+      - Comprehensive documentation produced
+      - Risk factors identified and mitigated

package/#Tools/APPIQ-METHOD/deployment/build/slash-commands/appiq.md

@@ -0,0 +1,273 @@
+# /appiq - Universal APPIQ Method Launcher
+
+**Quick Start**: `/appiq` - Intelligenter universeller Projekt-Launcher für alle Entwicklungsarten
+
+## 🚀 Überblick
+
+Der `/appiq` Command ist Ihr universeller Einstiegspunkt in die APPIQ Method. Egal ob Sie an Web-Anwendungen, Desktop-Apps, Mobile Apps oder Backend Services arbeiten - dieser Command führt Sie durch einen einfachen, geführten Prozess zur Auswahl des richtigen Workflows für Ihr Projekt.
+
+## ✨ Unterstützte Projekttypen
+
+- 🌐 **Web-Anwendungen** (React, Vue, Angular, Next.js, Full-Stack)
+- 💻 **Desktop-Anwendungen** (Electron, Cross-Platform Desktop Apps)  
+- 📱 **Mobile Apps** (Flutter, React Native, Cross-Platform Mobile)
+- ⚙️ **Backend Services** (Node.js, Python, Java, API Development)
+- 🔄 **Legacy/Brownfield** (Modernisierung bestehender Systeme)
+
+## 🎯 Verwendung
+
+```
+/appiq
+```
+
+## 📋 Interaktiver Workflow-Auswahl-Prozess
+
+### Schritt 1: Projekt-Status bestimmen
+```
+🚀 APPIQ Method Universal Launcher
+
+Arbeiten wir an einem neuen oder bestehenden Projekt?
+
+1. 🆕 Neues Projekt (Greenfield) - Wir bauen von Grund auf
+2. 🔧 Bestehendes Projekt (Brownfield) - Wir erweitern/verbessern etwas
+
+Antworte mit 1 oder 2:
+```
+
+### Schritt 2: Projekttyp identifizieren
+```
+📋 Lass mich verstehen, was wir bauen...
+
+Was für eine Art von Anwendung ist das?
+
+1. 🌐 Web-Anwendung (läuft im Browser)
+2. 💻 Desktop-Anwendung (Electron, Windows/Mac App)
+3. 📱 Mobile App (iOS/Android)
+4. ⚙️ Backend/API Service (Server, Database)
+5. 🤔 Bin mir nicht sicher - lass APPIQ entscheiden
+
+Antworte mit 1, 2, 3, 4 oder 5:
+```
+
+### Schritt 3: Intelligente Projekt-Erkennung (Option 5)
+
+**Für neue Projekte (Greenfield):**
+```
+🔍 Lass uns gemeinsam herausfinden, was das beste für dein Projekt ist...
+
+Beschreibe kurz dein Projekt in 1-2 Sätzen:
+(z.B. "Eine Ecommerce-Website mit Admin-Panel" oder "Eine Todo-App für Windows")
+
+Basierend auf deiner Beschreibung erkenne ich automatisch den Projekttyp.
+```
+
+**Für bestehende Projekte (Brownfield):**
+```
+🔍 Analysiere dein bestehendes Projekt...
+
+Ich schaue mir deine Projekt-Struktur an:
+✓ Suche nach package.json, pubspec.yaml, requirements.txt
+✓ Erkenne Framework-Dependencies (React, Flutter, Express, etc.)
+✓ Analysiere Ordner-Struktur (android/, ios/, public/, src/)
+
+Basierend darauf empfehle ich den optimalen Workflow.
+```
+
+## 🧠 Intelligente Workflow-Zuordnung
+
+### Greenfield Projekte (Neu)
+| Projekttyp | Workflow | Fokus-Bereich |
+|------------|----------|---------------|
+| 🌐 Web-App | `greenfield-fullstack.yaml` | Frontend + Backend Integration |
+| 💻 Desktop | `greenfield-fullstack.yaml` | Electron-spezifische Patterns |
+| 📱 Mobile | Mobile Platform Selection | Flutter/React Native Auswahl |
+| ⚙️ Backend | `greenfield-service.yaml` | API Design & Datenarchitektur |
+
+### Brownfield Projekte (Bestehend)
+| Projekttyp | Workflow | Fokus-Bereich |
+|------------|----------|---------------|
+| 🌐 Web-App | `brownfield-fullstack.yaml` | Sichere Integration & Modernisierung |
+| 💻 Desktop | `brownfield-fullstack.yaml` | Electron Upgrades & Features |
+| 📱 Mobile | Platform-spezifische Workflows | Flutter/React Native Enhancement |
+| ⚙️ Backend | `brownfield-service.yaml` | API Evolution & Skalierung |
+
+## 🔍 Automatische Projekt-Erkennung
+
+### File-basierte Erkennung (Brownfield)
+```javascript
+Erkennungslogik:
+├── package.json + "electron" → Desktop (Electron)
+├── package.json + "react-native" → Mobile (React Native)  
+├── pubspec.yaml → Mobile (Flutter)
+├── package.json + ("react"|"vue"|"angular"|"next") → Web
+├── package.json + ("express"|"fastify"|"koa") → Backend (Node.js)
+├── requirements.txt + Flask/Django patterns → Backend (Python)
+├── pom.xml oder build.gradle → Backend (Java)
+└── Fallback → Benutzer-geführte Auswahl
+```
+
+### Keyword-Erkennung (Greenfield)
+```javascript
+Keyword-Mapping:
+Web: ["website", "web", "browser", "online", "webapp", "ecommerce", "portal"]
+Desktop: ["desktop", "electron", "windows", "mac", "app", "gui", "standalone"]  
+Mobile: ["mobile", "ios", "android", "app store", "phone", "tablet", "cross-platform"]
+Backend: ["api", "server", "backend", "database", "service", "microservice", "rest"]
+```
+
+## 📱 Mobile-Spezifische Workflows (Legacy-Support)
+
+Für Mobile-Projekte wird eine zusätzliche Platform-Auswahl gestartet:
+
+### Greenfield Mobile
+```
+📱 Platform Selection für neue Mobile App:
+
+Welche mobile Plattform möchtest du verwenden?
+
+1. Flutter - Cross-platform mit Dart
+2. React Native - Cross-platform mit React/JavaScript
+3. Lass APPIQ Method basierend auf Requirements empfehlen
+
+Antworte mit 1, 2, oder 3:
+```
+
+### Brownfield Mobile
+```
+📱 Bestehende Mobile App Platform Detection:
+
+Erkannte Plattform: [Flutter/React Native]
+Verfügbare Enhancement-Workflows:
+- mobile-brownfield-flutter.yaml
+- mobile-brownfield-react-native.yaml
+
+Automatische Workflow-Auswahl basierend auf erkannter Plattform.
+```
+
+## 📝 Vollständige Beispiel-Interaktion
+
+### Beispiel 1: Neue E-Commerce Website
+```
+User: /appiq
+
+🚀 APPIQ Method Universal Launcher
+Arbeiten wir an einem neuen oder bestehenden Projekt?
+1. 🆕 Neues Projekt (Greenfield)
+2. 🔧 Bestehendes Projekt (Brownfield)
+
+User: 1
+
+📋 Lass mich verstehen, was wir bauen...
+Was für eine Art von Anwendung ist das?
+1. 🌐 Web-Anwendung
+2. 💻 Desktop-Anwendung  
+3. 📱 Mobile App
+4. ⚙️ Backend/API Service
+5. 🤔 Bin mir nicht sicher - lass APPIQ entscheiden
+
+User: 1
+
+🎯 Web-Anwendung ausgewählt!
+
+✅ Starte Greenfield Full-Stack Workflow für Web-Anwendungen...
+📍 Fokus: Full-Stack Web-Anwendung mit Frontend und Backend Komponenten
+📂 Erster Agent: analyst (erstellt Projekt-Brief)
+
+Der Workflow führt Sie durch:
+1. Projekt-Brief und Marktanalyse
+2. PRD (Product Requirements Document) Erstellung
+3. UX/UI Spezifikation für Web-Interface
+4. Full-Stack Architektur (Frontend + Backend)
+5. Story-basierte Entwicklung
+
+@analyst - Bitte beginne mit der Erstellung eines Projekt-Briefs für die Web-Anwendung...
+```
+
+### Beispiel 2: Bestehende Electron Desktop App
+```
+User: /appiq
+
+User: 2 (Bestehend)
+
+🔍 Analysiere dein bestehendes Projekt...
+
+Gefundene Indikatoren:
+✓ package.json mit "electron": "^25.0.0"
+✓ src/ Verzeichnis mit Electron-Main-Prozess
+✓ renderer/ Verzeichnis erkannt
+
+🎯 Erkannt: Desktop-Anwendung (Electron)
+
+✅ Starte Brownfield Full-Stack Workflow für Desktop-Anwendungen...
+📍 Fokus: Electron Desktop-Anwendung mit plattformspezifischen Optimierungen
+📂 Erster Agent: analyst (analysiert bestehende Desktop-App Struktur)
+
+Der Workflow führt Sie durch:
+1. Analyse der bestehenden Electron-Architektur
+2. Identifikation von Modernisierungs-Möglichkeiten
+3. Sicherheits- und Performance-Verbesserungen
+4. Feature-Enhancement Planung
+5. Story-basierte Implementierung
+
+@analyst - Bitte analysiere die bestehende Electron-Anwendung und identifiziere Verbesserungsmöglichkeiten...
+```
+
+## 🔄 Integration mit APPIQ Method Ecosystem
+
+### Agent-Integration
+Nach der Workflow-Auswahl werden die passenden Agents aktiviert:
+- **analyst** - Projekt-Analyse und Brief-Erstellung
+- **pm** - PRD und Requirements Management
+- **architect** - System-Architektur Design  
+- **ux-expert** - UI/UX Design (bei Web/Desktop/Mobile)
+- **dev** - Code-Implementierung
+- **qa** - Quality Assurance und Testing
+- **sm** - Story Management und Workflow-Orchestration
+
+### Expansion Pack Support
+Der `/appiq` Command erkennt automatisch installierte Expansion Packs:
+- **bmad-mobile-app-dev** - Mobile Development Specialists
+- **bmad-2d-game-dev** - Game Development (Unity/Phaser)
+- **bmad-infrastructure-devops** - Infrastructure & DevOps
+- Weitere Expansion Packs werden automatisch erkannt
+
+## ⚡ Performance & Effizienz
+
+### Schnelle Auswahl für Experten
+```
+/appiq → 2 → 2 → ✅ Brownfield Desktop Workflow (3 Klicks)
+```
+
+### Intelligente Defaults
+- Häufig verwendete Kombinationen werden erkannt
+- Context aus vorherigen Sessions wird berücksichtigt
+- Projekt-Patterns werden gelernt und vorgeschlagen
+
+## 🆚 Command-Vergleich
+
+| Command | Zweck | Zielgruppe |
+|---------|-------|------------|
+| `/appiq` | Universal Entry-Point | Alle Benutzer (Legacy-Name) |
+| `/start` | Universal Entry-Point | Neue Benutzer (Preferred) |
+| `*start` | bmad-orchestrator Direct | Power-User |
+| Direct Workflows | Spezifische Workflows | Experten |
+
+## 🔧 Backward Compatibility
+
+Der `/appiq` Command behält vollständige Rückwärtskompatibilität zu Mobile-only Workflows:
+- Alle bestehenden Mobile-Workflows funktionieren weiterhin
+- Mobile-spezifische Documentation bleibt erhalten
+- Expansion Pack `bmad-mobile-app-dev` wird vollständig unterstützt
+
+## ✅ Vorteile der Universal-Version
+
+1. **Ein Befehl für alles** - Web, Desktop, Mobile, Backend
+2. **Intelligente Erkennung** - Automatische Projekt-Typ Detection
+3. **Geführter Prozess** - Keine komplexen Workflow-Namen lernen
+4. **Vollständige Abdeckung** - Alle APPIQ Method Capabilities
+5. **Legacy-Support** - Bestehende Mobile Workflows bleiben verfügbar
+6. **Erweiterbar** - Expansion Packs werden automatisch integriert
+
+---
+
+**💡 Tipp:** `/appiq` ist der bewährte, universelle Entry-Point für alle APPIQ Method Funktionen. Für völlig neue Benutzer wird `/start` empfohlen, aber beide Commands bieten identische Funktionalität.