appiq-solution 1.3.3 → 1.4.3

package/#Tools/APPIQ-METHOD/bmad-core/tasks/smart-project-analysis.md

@@ -0,0 +1,289 @@
+# Smart Project Analysis Task
+
+## 📋 Overview
+This task provides intelligent analysis of existing projects to understand their structure, tech stack, and optimal BMAD integration approach.
+
+## 🎯 Task Objectives
+- Analyze project structure and detect tech stack
+- Identify existing architecture patterns
+- Assess BMAD integration opportunities
+- Recommend optimal workflow and agent configuration
+- Generate actionable improvement suggestions
+
+## 🔍 Analysis Framework
+
+### Phase 1: Project Structure Analysis
+
+#### File System Scanning
+```bash
+# Analyze project root structure
+- Check for configuration files (package.json, pubspec.yaml, etc.)
+- Identify source code organization
+- Detect build and deployment configurations
+- Analyze documentation structure
+- Check for existing BMAD installation
+```
+
+#### Configuration Detection
+```typescript
+interface ProjectConfig {
+  // Package managers and dependencies
+  packageManager: 'npm' | 'yarn' | 'pnpm' | 'pub' | 'pip' | 'cargo' | 'go mod';
+  dependencies: string[];
+  devDependencies: string[];
+  
+  // Build and development tools
+  buildTool: 'vite' | 'webpack' | 'rollup' | 'flutter build' | 'cargo' | 'go build';
+  linting: 'eslint' | 'tslint' | 'dart analyze' | 'clippy';
+  formatting: 'prettier' | 'dart format' | 'rustfmt';
+  
+  // Testing frameworks
+  testing: 'jest' | 'vitest' | 'cypress' | 'playwright' | 'flutter test';
+}
+```
+
+### Phase 2: Tech Stack Detection
+
+#### Frontend Framework Detection
+```typescript
+const detectFrontendFramework = (dependencies: string[]) => {
+  if (dependencies.includes('flutter')) return 'flutter';
+  if (dependencies.includes('react')) return 'react';
+  if (dependencies.includes('vue')) return 'vue';
+  if (dependencies.includes('@angular/core')) return 'angular';
+  if (dependencies.includes('svelte')) return 'svelte';
+  return 'vanilla';
+};
+```
+
+#### Backend Service Detection
+```typescript
+const detectBackendServices = (dependencies: string[], files: string[]) => {
+  const services = [];
+  
+  // Firebase detection
+  if (dependencies.includes('firebase') || files.includes('firebase.json')) {
+    services.push('firebase');
+  }
+  
+  // Supabase detection
+  if (dependencies.includes('@supabase/supabase-js')) {
+    services.push('supabase');
+  }
+  
+  // Traditional backend
+  if (dependencies.includes('express') || dependencies.includes('fastify')) {
+    services.push('node-backend');
+  }
+  
+  return services;
+};
+```
+
+#### State Management Detection
+```typescript
+const detectStateManagement = (dependencies: string[], framework: string) => {
+  switch (framework) {
+    case 'flutter':
+      if (dependencies.includes('flutter_bloc')) return 'cubit/bloc';
+      if (dependencies.includes('riverpod')) return 'riverpod';
+      break;
+    case 'react':
+      if (dependencies.includes('@reduxjs/toolkit')) return 'redux-toolkit';
+      if (dependencies.includes('zustand')) return 'zustand';
+      if (dependencies.includes('valtio')) return 'valtio';
+      break;
+    case 'vue':
+      if (dependencies.includes('vuex')) return 'vuex';
+      if (dependencies.includes('pinia')) return 'pinia';
+      break;
+  }
+  return 'default';
+};
+```
+
+### Phase 3: Architecture Pattern Analysis
+
+#### Code Structure Analysis
+```typescript
+interface ArchitectureAnalysis {
+  pattern: 'clean-architecture' | 'mvc' | 'layered' | 'component-based' | 'mixed';
+  layerSeparation: 'strict' | 'loose' | 'none';
+  dependencyDirection: 'correct' | 'violated' | 'unclear';
+  testCoverage: 'high' | 'medium' | 'low' | 'none';
+  documentation: 'comprehensive' | 'partial' | 'minimal' | 'none';
+}
+```
+
+#### Flutter-Specific Analysis
+```dart
+// Analyze Flutter project structure
+final flutterAnalysis = {
+  'architecture': detectCleanArchitecture(),
+  'stateManagement': detectStatePattern(),
+  'localization': hasLocalization(),
+  'responsiveDesign': hasResponsiveDesign(),
+  'testing': analyzeTestStructure(),
+};
+```
+
+### Phase 4: BMAD Integration Assessment
+
+#### Current BMAD Status
+```typescript
+interface BMADStatus {
+  installed: boolean;
+  version: string | null;
+  configuration: 'complete' | 'partial' | 'none';
+  agents: string[];
+  workflows: string[];
+  expansionPacks: string[];
+}
+```
+
+#### Integration Opportunities
+```typescript
+interface IntegrationOpportunities {
+  // Missing BMAD components
+  missingAgents: string[];
+  missingWorkflows: string[];
+  missingTemplates: string[];
+  
+  // Improvement opportunities
+  architectureUpgrades: string[];
+  qualityImprovements: string[];
+  securityEnhancements: string[];
+  performanceOptimizations: string[];
+}
+```
+
+## 📊 Analysis Output
+
+### Comprehensive Project Report
+```markdown
+# Project Analysis Report
+
+## 📋 Project Overview
+- **Name**: [Project Name]
+- **Type**: [Greenfield/Brownfield]
+- **Structure**: [Monorepo/Multi-repo/Single-app]
+- **Size**: [Small/Medium/Large] ([LOC count])
+
+## 🛠️ Tech Stack Analysis
+- **Frontend**: [Framework] ([Version])
+- **Backend**: [Service/Framework] ([Version])
+- **Database**: [Type] ([Version])
+- **State Management**: [Pattern/Library]
+- **Testing**: [Frameworks and coverage]
+- **Build Tools**: [Tools and configuration]
+
+## 🏗️ Architecture Assessment
+- **Pattern**: [Architecture pattern]
+- **Quality Score**: [Score/10]
+- **Maintainability**: [High/Medium/Low]
+- **Scalability**: [High/Medium/Low]
+- **Test Coverage**: [Percentage]
+
+## 🎯 BMAD Integration Status
+- **Current Status**: [Not installed/Partially configured/Fully configured]
+- **Compatible Agents**: [List of applicable agents]
+- **Recommended Workflow**: [Workflow type]
+- **Expansion Packs**: [Recommended packs]
+
+## 🚀 Recommendations
+
+### Immediate Actions
+1. [Priority 1 recommendation]
+2. [Priority 2 recommendation]
+3. [Priority 3 recommendation]
+
+### Architecture Improvements
+- [Architecture improvement 1]
+- [Architecture improvement 2]
+
+### Quality Enhancements
+- [Quality enhancement 1]
+- [Quality enhancement 2]
+
+### Security Considerations
+- [Security recommendation 1]
+- [Security recommendation 2]
+
+## 📋 Next Steps
+1. **BMAD Setup**: [Setup instructions if needed]
+2. **Agent Configuration**: [Agent setup recommendations]
+3. **Workflow Selection**: [Recommended workflow]
+4. **Documentation**: [Documentation tasks]
+```
+
+## 🤖 Execution Steps
+
+### Step 1: Initialize Analysis
+> 🔍 **Starting Project Analysis**
+> 
+> I'm analyzing your project to understand its structure and recommend the best BMAD integration approach.
+> 
+> This will take a moment...
+
+### Step 2: Present Findings
+> 📊 **Analysis Complete**
+> 
+> **Project Type**: [Detected type]
+> **Tech Stack**: [Primary technologies]
+> **Architecture**: [Current pattern]
+> **BMAD Status**: [Current status]
+> 
+> **Quality Score**: [Score]/10
+> 
+> Would you like to see the detailed report? (Y/n)
+
+### Step 3: Provide Recommendations
+> 🎯 **Recommendations**
+> 
+> Based on my analysis, here are my top recommendations:
+> 
+> **Priority 1**: [Most important recommendation]
+> **Priority 2**: [Second priority]
+> **Priority 3**: [Third priority]
+> 
+> **Optimal BMAD Configuration**:
+> - **Agents**: [Recommended agents]
+> - **Workflow**: [Recommended workflow]
+> - **Expansion Packs**: [If applicable]
+> 
+> Would you like me to:
+> 1. **Set up BMAD** with recommended configuration
+> 2. **Create improvement plan** with detailed steps
+> 3. **Generate documentation** for current architecture
+> 4. **Start with specific recommendation**
+> 
+> What would you prefer? (1/2/3/4)
+
+### Step 4: Action Execution
+Based on user choice, execute the selected action with intelligent guidance and validation.
+
+## 🔧 Implementation Details
+
+### Analysis Algorithms
+- **Dependency Graph Analysis**: Understand component relationships
+- **Code Complexity Metrics**: Assess maintainability and scalability
+- **Pattern Recognition**: Identify architectural patterns and anti-patterns
+- **Quality Metrics**: Calculate code quality scores
+- **Security Scanning**: Identify potential security issues
+
+### Intelligence Features
+- **Context Awareness**: Understand project domain and requirements
+- **Best Practice Validation**: Check against industry standards
+- **Performance Analysis**: Identify performance bottlenecks
+- **Scalability Assessment**: Evaluate scaling potential
+- **Maintainability Review**: Assess long-term maintainability
+
+## 📋 Success Criteria
+- [ ] Complete project structure analyzed
+- [ ] Tech stack accurately detected
+- [ ] Architecture pattern identified
+- [ ] Quality metrics calculated
+- [ ] BMAD integration opportunities identified
+- [ ] Actionable recommendations provided
+- [ ] Clear next steps outlined
+- [ ] User guided to optimal solution

package/#Tools/APPIQ-METHOD/bmad-core/templates/flutter-mobile-prd-tmpl.yaml

@@ -0,0 +1,330 @@
+document:
+  type: Flutter Mobile Product Requirements Document
+  version: 1.0
+  output_file: flutter-prd.md
+
+metadata:
+  product_name: "[Product Name]"
+  version: "[Version]"
+  created_date: "[Date]"
+  author: "[PM Name]"
+  stakeholders: "[Key Stakeholders]"
+  target_platforms: 
+    - iOS (minimum version 12.0)
+    - Android (minimum SDK 21)
+  flutter_version: "[Flutter Version]"
+  architecture: "Clean Architecture with Feature-based Structure"
+
+sections:
+  - name: executive_summary
+    title: "📱 Executive Summary"
+    prompt: |
+      Provide a concise overview of the Flutter mobile application including:
+      - Core value proposition for mobile users
+      - Primary target audience and mobile usage patterns
+      - Key mobile-specific features and capabilities
+      - Business objectives and success metrics
+      - Market opportunity in mobile space
+
+  - name: mobile_context
+    title: "📲 Mobile Context & Market Analysis"
+    prompt: |
+      Define the mobile-specific context:
+      - Mobile market analysis and competitive landscape
+      - Target user mobile behavior patterns
+      - Device usage scenarios (phone, tablet, offline/online)
+      - Platform-specific considerations (iOS vs Android)
+      - App store positioning and discovery strategy
+
+  - name: user_personas
+    title: "👤 Mobile User Personas"
+    prompt: |
+      Define mobile-specific user personas including:
+      - Primary mobile user types and demographics
+      - Mobile usage patterns and device preferences
+      - User journey on mobile devices
+      - Pain points in current mobile solutions
+      - Mobile-specific needs and expectations
+
+  - name: feature_requirements
+    title: "🎯 Feature Requirements (Flutter Clean Architecture)"
+    prompt: |
+      Organize features using Flutter's feature-based architecture:
+      
+      ## Core Features
+      For each major feature, define:
+      
+      ### [Feature Name] Feature
+      **Business Logic (Domain Layer):**
+      - Entities: [Define business entities]
+      - Use Cases: [Define business use cases]
+      - Repository Interfaces: [Define data contracts]
+      - Business Rules: [Define validation rules]
+      
+      **Data Management (Data Layer):**
+      - Data Sources: [Remote APIs, Local storage]
+      - Models: [JSON serialization models with Freezed]
+      - Repository Implementations: [Data access implementations]
+      - Caching Strategy: [Offline/online data handling]
+      
+      **User Interface (Presentation Layer):**
+      - Pages/Screens: [List all screens for this feature]
+      - Widgets: [Reusable UI components]
+      - State Management: [Cubit states and events]
+      - Navigation: [Route definitions and deep linking]
+      
+      **Localization:**
+      - Translation Keys: [All text content keys]
+      - Supported Languages: [List of supported locales]
+      
+      **Testing Requirements:**
+      - Unit Tests: [Business logic testing]
+      - Widget Tests: [UI component testing]
+      - Integration Tests: [End-to-end user flows]
+
+  - name: ui_ux_requirements
+    title: "🎨 UI/UX Requirements (Material Design 3)"
+    prompt: |
+      Define Material Design 3 mobile UI requirements:
+      
+      **Design System:**
+      - Material Design 3 theme and color scheme
+      - Typography scale and text styles
+      - Component library and design tokens
+      - Dark/Light theme support
+      
+      **Responsive Design:**
+      - Phone layouts (small screens)
+      - Tablet layouts (large screens)
+      - Orientation handling (portrait/landscape)
+      - Accessibility requirements (WCAG compliance)
+      
+      **Navigation Patterns:**
+      - Bottom navigation or navigation rail
+      - App bar configurations
+      - Drawer navigation (if applicable)
+      - Deep linking and routing structure
+      
+      **Mobile-Specific Interactions:**
+      - Touch gestures and swipe patterns
+      - Pull-to-refresh implementations
+      - Loading states and error handling UI
+      - Offline state indicators
+
+  - name: technical_requirements
+    title: "⚙️ Technical Requirements"
+    prompt: |
+      Define Flutter-specific technical requirements:
+      
+      **Flutter Architecture:**
+      - Clean Architecture implementation
+      - Feature-based folder structure
+      - Dependency injection with GetIt/Injectable
+      - State management with Cubit/BLoC
+      
+      **Core Dependencies:**
+      - flutter_bloc for state management
+      - get_it + injectable for dependency injection
+      - freezed + json_serializable for models
+      - dio for networking
+      - hive for local storage
+      - go_router for navigation
+      - equatable for value equality
+      
+      **Performance Requirements:**
+      - App startup time targets
+      - Screen transition performance
+      - Memory usage constraints
+      - Battery optimization considerations
+      
+      **Platform Integration:**
+      - Device capabilities (camera, location, etc.)
+      - Push notifications
+      - In-app purchases (if applicable)
+      - Native platform features
+
+  - name: backend_integration
+    title: "🔌 Backend Integration"
+    prompt: |
+      Define backend integration requirements:
+      
+      **API Requirements:**
+      - RESTful API endpoints specification
+      - Authentication and authorization flows
+      - Data synchronization patterns
+      - Real-time data updates (WebSocket/Server-Sent Events)
+      
+      **Data Models:**
+      - JSON structure definitions
+      - Data validation requirements
+      - Error response formats
+      - Pagination and filtering patterns
+      
+      **Offline Capabilities:**
+      - Local data caching strategy
+      - Offline-first functionality
+      - Data synchronization on reconnection
+      - Conflict resolution patterns
+
+  - name: security_requirements
+    title: "🔒 Security Requirements"
+    prompt: |
+      Define mobile security requirements:
+      
+      **Data Protection:**
+      - Sensitive data encryption (flutter_secure_storage)
+      - Biometric authentication integration
+      - Session management and token refresh
+      - Certificate pinning for API calls
+      
+      **Input Validation:**
+      - Form validation patterns
+      - Sanitization of user inputs
+      - Protection against injection attacks
+      - File upload security
+      
+      **Privacy Compliance:**
+      - GDPR/CCPA compliance requirements
+      - User consent management
+      - Data retention policies
+      - Analytics and tracking permissions
+
+  - name: localization_requirements
+    title: "🌍 Localization & Accessibility"
+    prompt: |
+      Define internationalization requirements:
+      
+      **Multi-Language Support:**
+      - Supported languages and locales
+      - Text direction support (LTR/RTL)
+      - Date, time, and number formatting
+      - Currency and unit localization
+      
+      **Accessibility:**
+      - Screen reader support
+      - Voice navigation
+      - High contrast mode
+      - Font size scaling
+      - Keyboard navigation support
+
+  - name: performance_metrics
+    title: "📊 Performance & Success Metrics"
+    prompt: |
+      Define measurable success criteria:
+      
+      **Technical Performance:**
+      - App launch time: [Target in milliseconds]
+      - Screen transition time: [Target]
+      - API response time: [Acceptable ranges]
+      - Memory usage: [Maximum limits]
+      - Battery consumption: [Optimization targets]
+      
+      **Business Metrics:**
+      - User engagement metrics
+      - Conversion rates
+      - User retention rates
+      - App store ratings targets
+      - Feature adoption rates
+
+  - name: development_phases
+    title: "🚀 Development Phases"
+    prompt: |
+      Define development phases using Flutter feature-based approach:
+      
+      **Phase 1: Core Foundation**
+      - Project setup and architecture
+      - Authentication and user management
+      - Core navigation structure
+      - Basic UI components and theme
+      
+      **Phase 2: Essential Features**
+      - [List core features with priorities]
+      - Each feature includes all layers (data/domain/presentation)
+      - Basic testing implementation
+      
+      **Phase 3: Advanced Features**
+      - [List advanced features]
+      - Performance optimizations
+      - Advanced animations and interactions
+      
+      **Phase 4: Polish & Launch**
+      - Comprehensive testing
+      - App store preparation
+      - Performance optimization
+      - Launch strategy
+
+  - name: constraints_assumptions
+    title: "⚠️ Constraints & Assumptions"
+    prompt: |
+      Document constraints and assumptions:
+      
+      **Technical Constraints:**
+      - Flutter version compatibility
+      - Minimum device requirements
+      - Third-party SDK limitations
+      - App store guidelines compliance
+      
+      **Business Constraints:**
+      - Budget limitations
+      - Timeline constraints
+      - Resource availability
+      - Regulatory requirements
+      
+      **Assumptions:**
+      - User device capabilities
+      - Network connectivity assumptions
+      - Backend service availability
+      - Third-party service reliability
+
+  - name: acceptance_criteria
+    title: "✅ Acceptance Criteria"
+    prompt: |
+      Define clear acceptance criteria for each feature:
+      
+      **Feature Completion Criteria:**
+      - All layers implemented (data/domain/presentation)
+      - Unit tests coverage > 80%
+      - Widget tests for all UI components
+      - Integration tests for user flows
+      - Localization keys implemented
+      - Accessibility compliance verified
+      - Performance benchmarks met
+      
+      **Quality Gates:**
+      - DRY: No code duplication
+      - Readable: Clear code structure
+      - Maintainable: Modular architecture
+      - Performant: Meets performance targets
+      - Testable: Comprehensive test coverage
+      - Secure: Security validation passed
+      - Localized: Multi-language support
+
+instructions:
+  pre_fill: |
+    Before starting this PRD:
+    1. Review any existing project documentation
+    2. Understand the target audience and mobile usage patterns
+    3. Research competitor mobile apps and market positioning
+    4. Consider Flutter's capabilities and limitations
+    5. Plan for feature-based architecture from the beginning
+
+  post_completion: |
+    After completing this PRD:
+    1. Validate with stakeholders and mobile UX experts
+    2. Review technical feasibility with Flutter developers  
+    3. Ensure alignment with business objectives
+    4. Plan for architecture document creation
+    5. Prepare for feature-based story creation by Scrum Master
+    6. Save as docs/flutter-prd.md for development team reference
+
+  quality_checklist:
+    - "All features mapped to Flutter's clean architecture layers"
+    - "Material Design 3 principles incorporated"
+    - "Responsive design considerations included"
+    - "Localization requirements defined"
+    - "Performance metrics are measurable"
+    - "Security requirements are comprehensive"
+    - "Accessibility compliance addressed"
+    - "Backend integration patterns defined"
+    - "Testing strategy covers all layers"
+    - "Development phases are realistic and feature-based"