appiq-solution 1.3.2 → 1.4.2

package/#Tools/APPIQ-METHOD/bmad-core/tasks/create-flutter-story.md

@@ -0,0 +1,197 @@
+# Create Flutter Story Task
+
+## Overview
+This task creates a detailed Flutter development story following Clean Architecture principles with feature-based organization. The story will include all three layers (data/domain/presentation) and comprehensive testing requirements.
+
+## Prerequisites
+- Flutter PRD document available
+- Flutter architecture document (if applicable)
+- Feature requirements clearly defined
+- UI/UX specifications available
+
+## Task Execution
+
+### Step 1: Gather Requirements
+**Action:** Collect and analyze story requirements
+**Process:**
+1. Read Flutter PRD or feature requirements
+2. Review UI/UX specifications if available
+3. Understand user needs and business value
+4. Identify technical constraints and dependencies
+5. Determine story scope and complexity
+
+**Deliverable:** Clear understanding of feature requirements
+
+### Step 2: Define User Story
+**Action:** Create user story following standard format
+**Process:**
+1. Identify the user persona and role
+2. Define the specific functionality/goal
+3. Articulate the business value/benefit
+4. Add mobile-specific context and usage scenarios
+5. Consider offline/online behavior requirements
+
+**Template:**
+```
+As a [type of user]
+I want [goal/functionality]
+So that [benefit/value]
+
+Mobile Context:
+- Device usage scenario
+- User interaction patterns
+- Performance expectations
+```
+
+### Step 3: Create Acceptance Criteria
+**Action:** Define comprehensive, testable acceptance criteria
+**Process:**
+1. **Functional Criteria:** Define what the feature must do
+2. **UI/UX Criteria:** Material Design 3, responsive design, accessibility
+3. **Technical Criteria:** Clean Architecture, state management, error handling
+4. **Performance Criteria:** Loading times, animations, memory usage
+
+**Quality Check:** Each criterion must be:
+- Specific and measurable
+- Testable with clear pass/fail conditions
+- Aligned with user value and business goals
+
+### Step 4: Break Down Flutter Implementation Tasks
+**Action:** Organize tasks by Flutter Clean Architecture layers
+**Process:**
+
+#### A. Presentation Layer Tasks
+1. **UI Implementation:**
+   - Create feature pages/screens with Material 3 design
+   - Implement custom widgets and components  
+   - Set up responsive layouts for phone/tablet
+   - Add animations and micro-interactions
+   - Implement accessibility features
+
+2. **State Management (Cubit):**
+   - Create Cubit class with business logic coordination
+   - Define State classes with Equatable
+   - Implement state transitions and error handling
+   - Connect UI to Cubit with BlocBuilder/BlocListener
+
+3. **Navigation & Routing:**
+   - Define routes and navigation paths
+   - Implement deep linking (if required)
+   - Add navigation transitions
+
+#### B. Domain Layer Tasks
+1. **Business Entities:**
+   - Create entity classes with Equatable
+   - Define entity relationships and properties
+   - Add entity validation rules
+
+2. **Use Cases:**
+   - Implement use case classes with @injectable
+   - Add business logic and validation
+   - Define Either<Failure, Success> return types
+
+3. **Repository Interfaces:**
+   - Define repository abstract classes
+   - Specify method signatures and return types
+
+#### C. Data Layer Tasks
+1. **Data Models:**
+   - Create model classes with @freezed annotation
+   - Add JSON serialization
+   - Implement model to entity conversion methods
+
+2. **Repository Implementations:**
+   - Implement concrete repository classes
+   - Add error handling and data transformation
+
+3. **Data Sources:**
+   - Create remote data source for API calls
+   - Implement local data source for caching
+   - Add offline-first functionality (if required)
+
+#### D. Cross-Cutting Tasks
+1. **Localization & Theming:**
+   - Add all text content to ARB files
+   - Implement RTL support
+   - Verify dark/light theme compatibility
+
+2. **Testing:**
+   - Unit tests for domain layer
+   - Unit tests for data layer
+   - Widget tests for UI components
+   - Cubit/state management tests
+   - Integration tests for user flows
+
+### Step 5: Add Technical Implementation Details
+**Action:** Provide technical guidance for developers
+**Process:**
+1. List required Flutter dependencies
+2. Define file structure following feature-based architecture
+3. Specify key implementation patterns
+4. Include performance considerations
+5. Add security requirements (if applicable)
+
+### Step 6: Define Testing Requirements
+**Action:** Create comprehensive testing strategy
+**Process:**
+1. **Unit Tests:** Domain and data layer testing with mocks
+2. **Widget Tests:** UI component testing in isolation
+3. **Cubit Tests:** State management testing with bloc_test
+4. **Integration Tests:** End-to-end user flow testing
+5. **Accessibility Tests:** Screen reader and semantic testing
+
+**Coverage Target:** Minimum 80% code coverage, 100% for business logic
+
+### Step 7: Add Development Notes
+**Action:** Include additional guidance and considerations
+**Process:**
+1. Performance optimization tips
+2. Accessibility implementation guidelines
+3. Localization best practices
+4. Code quality standards
+5. Common pitfalls and solutions
+
+### Step 8: Create Definition of Done
+**Action:** Define clear completion criteria
+**Process:**
+1. **Implementation Complete:** All tasks and layers implemented
+2. **Code Quality:** Follows Flutter best practices and standards
+3. **Testing Complete:** All tests written and passing
+4. **Performance Verified:** Meets performance benchmarks
+5. **Documentation:** Code documented and file list updated
+6. **Review Process:** Code review, design review, QA testing completed
+
+## Template Usage
+**Template:** Use `flutter-story-tmpl.yaml` for consistent story structure
+
+## Quality Validation
+Before marking story as complete, verify:
+- [ ] Story follows standard user story format
+- [ ] Acceptance criteria are specific and testable
+- [ ] Tasks cover all Flutter architecture layers
+- [ ] Technical details provide clear implementation guidance  
+- [ ] Testing requirements are comprehensive
+- [ ] Performance and accessibility requirements included
+- [ ] Localization requirements specified
+- [ ] Definition of done is complete and measurable
+
+## Handoff Process
+1. Review story with Product Owner for business value alignment
+2. Review with Tech Lead for technical feasibility
+3. Estimate story points with development team
+4. Ensure all dependencies are identified and available
+5. Confirm story is ready for development sprint
+
+## Success Criteria
+- Story provides complete implementation guidance for developers
+- All acceptance criteria are testable and measurable
+- Technical approach follows Flutter Clean Architecture principles
+- Story scope is appropriate for single sprint completion
+- Dependencies and integration points are clearly identified
+
+## Notes
+- Keep stories focused on single feature or user flow
+- Ensure story can be completed within one sprint (usually 1-2 weeks)
+- Consider breaking large features into multiple stories
+- Always include mobile-specific considerations (performance, battery, offline)
+- Maintain consistency with existing codebase patterns and standards

package/#Tools/APPIQ-METHOD/bmad-core/tasks/intelligent-epic-creation.md

@@ -0,0 +1,234 @@
+# Intelligent AppIQ Project Creation Task
+
+## 📋 Overview
+This task provides an intelligent, guided approach to project creation that automatically detects project context and guides users through the optimal workflow.
+
+## 🎯 Task Objectives
+- Automatically detect project type (Greenfield vs Brownfield)
+- Analyze existing tech stack and project structure
+- Guide user through PRD creation or validation
+- Launch appropriate architecture workflow
+- Set up optimal development environment
+
+## 🤖 Execution Workflow
+
+### Phase 1: Project Context Detection
+
+#### Step 1: Analyze Current Environment
+```bash
+# Check for existing project indicators
+- package.json (Node.js/React/Vue/Angular)
+- pubspec.yaml (Flutter)
+- requirements.txt (Python)
+- Cargo.toml (Rust)
+- go.mod (Go)
+- composer.json (PHP)
+```
+
+#### Step 2: Detect Project Type
+**Ask user to confirm detection:**
+
+> 🔍 **Project Analysis Complete**
+> 
+> I've detected the following about your project:
+> - **Project Type**: [Greenfield/Brownfield]
+> - **Tech Stack**: [Detected frameworks and tools]
+> - **Structure**: [Monorepo/Multi-repo/Single app]
+> 
+> Is this correct? (Y/n)
+
+### Phase 2: PRD Workflow Selection
+
+#### For Greenfield Projects:
+1. **Check for existing PRD**:
+   - Look for `docs/prd.md`
+   - Look for `docs/requirements.md`
+   - Look for any `.md` files with PRD content
+
+2. **If no PRD exists**:
+   > 📝 **PRD Creation Required**
+   > 
+   > I don't see a PRD (Product Requirements Document) in your project.
+   > 
+   > Options:
+   > 1. **Quick Start**: I'll guide you through creating a PRD interactively
+   > 2. **Upload Existing**: You have a PRD file to upload
+   > 3. **Skip for Now**: Start with basic architecture (not recommended)
+   > 
+   > What would you like to do? (1/2/3)
+
+3. **If PRD exists**:
+   > ✅ **PRD Found**
+   > 
+   > I found your PRD at `docs/prd.md`. Let me validate it meets BMAD requirements...
+   > 
+   > [Analysis results]
+   > 
+   > Would you like to:
+   > 1. **Continue with existing PRD**
+   > 2. **Update/enhance the PRD**
+   > 3. **Create a new PRD**
+
+#### For Brownfield Projects:
+1. **Analyze existing codebase**:
+   - Detect current architecture patterns
+   - Identify existing components and services
+   - Analyze database schemas and API endpoints
+   - Check for existing documentation
+
+2. **Generate brownfield analysis**:
+   > 🔍 **Brownfield Analysis Complete**
+   > 
+   > **Detected Architecture**: [Clean Architecture/MVC/Layered/etc.]
+   > **Key Components**: [List of major components]
+   > **Database**: [Detected database type and schema]
+   > **API Style**: [REST/GraphQL/tRPC]
+   > 
+   > I'll help you create a PRD that aligns with your existing architecture.
+
+### Phase 3: Architecture Workflow
+
+#### Step 1: Architecture Agent Selection
+Based on detected tech stack, automatically select the appropriate architecture agent:
+
+- **Flutter Projects** → `flutter-mobile-architecture-tmpl.yaml`
+- **React/Vue/Angular** → `front-end-architecture-tmpl.yaml`
+- **Full Stack** → `fullstack-architecture-tmpl.yaml`
+- **Backend Only** → `architecture-tmpl.yaml`
+- **Brownfield** → `brownfield-architecture-tmpl.yaml`
+
+#### Step 2: Launch Architecture Creation
+> 🏗️ **Architecture Setup**
+> 
+> Based on your tech stack, I'm launching the **[Architecture Type]** workflow.
+> 
+> This will create a comprehensive architecture document that includes:
+> - Technology stack decisions
+> - Component architecture
+> - Database design
+> - API specifications
+> - Development workflow
+> 
+> Ready to proceed? (Y/n)
+
+### Phase 4: Development Environment Setup
+
+#### Step 1: Agent Team Configuration
+Automatically configure the optimal agent team based on project type:
+
+**For Flutter Projects**:
+```yaml
+agents:
+  - bmad-orchestrator
+  - analyst (if needed)
+  - pm
+  - architect
+  - po
+  - flutter-ui-agent
+  - flutter-cubit-agent
+  - flutter-domain-agent
+  - flutter-data-agent
+  - shared-components-agent
+  - qa
+  - sm
+```
+
+**For Web Projects**:
+```yaml
+agents:
+  - bmad-orchestrator
+  - analyst (if needed)
+  - pm
+  - architect
+  - po
+  - dev
+  - qa
+  - sm
+```
+
+#### Step 2: Workflow Initialization
+> ⚙️ **Development Environment Setup**
+> 
+> I'm configuring your development environment:
+> 
+> ✅ Agent team configured for [Project Type]
+> ✅ Workflow templates selected
+> ✅ Quality gates established
+> ✅ Security validation enabled
+> 
+> **Next Steps**:
+> 1. PRD creation/validation
+> 2. Architecture document generation
+> 3. Epic and story creation
+> 4. Development workflow initiation
+
+### Phase 5: Smart Guidance
+
+#### Provide Context-Aware Next Steps
+> 🎯 **Ready to Start Development**
+> 
+> Your BMAD environment is configured! Here's what happens next:
+> 
+> **Immediate Actions**:
+> 1. **PRD Review**: [If needed] Review and approve your PRD
+> 2. **Architecture Creation**: Generate your architecture document
+> 3. **Epic Planning**: Break down your PRD into actionable epics
+> 
+> **Development Workflow**:
+> 1. **Story Creation**: SM agent will create detailed development stories
+> 2. **Development**: Dev agents will implement features following Clean Architecture
+> 3. **Quality Assurance**: QA agent will validate all implementations
+> 
+> **Commands Available**:
+> - `/story` - Create a new development story
+> - `/analyze` - Analyze current project status
+> - `/help` - Get context-aware help
+> 
+> Would you like me to start with PRD creation? (Y/n)
+
+## 🔧 Implementation Details
+
+### Tech Stack Detection Logic
+```typescript
+interface ProjectContext {
+  type: 'greenfield' | 'brownfield';
+  techStack: {
+    frontend?: 'react' | 'vue' | 'angular' | 'flutter' | 'vanilla';
+    backend?: 'node' | 'python' | 'go' | 'rust' | 'php' | 'firebase' | 'supabase';
+    database?: 'postgresql' | 'mysql' | 'mongodb' | 'sqlite' | 'firestore';
+    stateManagement?: 'redux' | 'zustand' | 'cubit' | 'bloc' | 'vuex' | 'pinia';
+  };
+  structure: 'monorepo' | 'multi-repo' | 'single-app';
+  hasExistingDocs: boolean;
+  hasBMAD: boolean;
+}
+```
+
+### Intelligent Defaults
+- **Flutter Projects**: Enable Clean Architecture, Cubit state management, multi-language support
+- **React Projects**: Enable TypeScript, modern hooks, component-based architecture
+- **Full Stack**: Enable shared types, API-first design, comprehensive testing
+- **Brownfield**: Respect existing patterns while introducing BMAD workflows
+
+### Error Prevention
+- Validate PRD completeness before architecture creation
+- Check for conflicting dependencies
+- Ensure proper folder structure
+- Validate agent compatibility with tech stack
+
+## 📋 Success Criteria
+- [ ] Project type correctly detected
+- [ ] Tech stack accurately identified
+- [ ] Appropriate workflow selected and configured
+- [ ] User guided through each step with clear options
+- [ ] Development environment properly initialized
+- [ ] Clear next steps provided
+- [ ] All quality gates established
+- [ ] Security validation enabled
+
+## 🎯 User Experience Goals
+- **Zero Configuration**: Works out of the box with intelligent defaults
+- **Progressive Disclosure**: Only shows relevant options based on context
+- **Error Prevention**: Validates inputs and prevents common mistakes
+- **Clear Guidance**: Provides clear next steps at every stage
+- **Flexibility**: Allows overrides of automatic detection when needed