@appiq/flutter-workflow 1.4.3 → 2.1.0

package/templates/feature-template.md

@@ -1,81 +1,167 @@
 ---
-name: {{FEATURE_NAME}}
-ui: open
-domain: open
-data: open
-security: open
-test: open
-status: open
-created: {{CREATED_DATE}}
-updated: {{UPDATED_DATE}}
+name: ${FEATURE_NAME}
+ui: ${UI_STATUS:open}
+cubit: ${CUBIT_STATUS:open}
+domain: ${DOMAIN_STATUS:open}
+data: ${DATA_STATUS:open}
+security: ${SECURITY_STATUS:open}
+test: ${TEST_STATUS:open}
+integration: ${INTEGRATION_STATUS:open}
+status: ${OVERALL_STATUS:open}
+created: ${CREATED_DATE}
+updated: ${UPDATED_DATE}
+completion: ${COMPLETION_PERCENTAGE:0}%
+current_agent: ${CURRENT_AGENT:none}
+current_phase: ${CURRENT_PHASE:initialization}
 ---
 
-# {{FEATURE_NAME}}
+# ${FEATURE_NAME} - Flutter Feature Development
 
-## Description
-Describe your {{FEATURE_NAME}} feature here. This will be analyzed by the PO Agent to create detailed tasks and planning.
+## 📊 Current Status
+- **Overall Progress**: ${COMPLETION_PERCENTAGE:0}% Complete
+- **Current Phase**: ${CURRENT_PHASE:initialization}
+- **Active Agent**: ${CURRENT_AGENT:none}
+- **Last Updated**: ${UPDATED_DATE}
 
-## User Story
-As a [user type], I want [functionality] so that [benefit].
+## 🎯 Feature Description
+${FEATURE_DESCRIPTION:Describe your feature here. This will be analyzed by the PO Agent to create detailed tasks and planning.}
 
-## Requirements
+## 👤 User Story
+${USER_STORY:As a [user type], I want [functionality] so that [benefit].}
+
+## 📋 Requirements
+${REQUIREMENTS_LIST:
 - [ ] Functional requirement 1
 - [ ] Functional requirement 2  
 - [ ] Functional requirement 3
 - [ ] Non-functional requirement 1
 - [ ] Non-functional requirement 2
+}
 
-## Acceptance Criteria
+## ✅ Acceptance Criteria
+${ACCEPTANCE_CRITERIA:
 - [ ] Given [context], when [action], then [expected result]
 - [ ] Given [context], when [action], then [expected result]
 - [ ] Given [context], when [action], then [expected result]
+}
 
-## Technical Notes
+## 🏗️ Technical Specifications
+${TECHNICAL_NOTES:
 - Add any technical considerations
 - Architecture requirements
 - Dependencies on other features
 - Performance requirements
 - Security considerations
+}
 
-## UI/UX Requirements  
+## 🎨 UI/UX Requirements  
+${UI_REQUIREMENTS:
 - Screen designs and layouts
 - User interaction patterns
 - Responsive design requirements
 - Accessibility requirements
 - Animation and transition needs
+}
 
-## Data Requirements
+## 📊 Data Requirements
+${DATA_REQUIREMENTS:
 - Data models and entities needed
 - API endpoints required
 - Local storage needs
 - Caching strategies
 - Offline functionality requirements
+}
 
-## Security Requirements
+## 🔒 Security Requirements
+${SECURITY_REQUIREMENTS:
 - Authentication needs
 - Authorization requirements
 - Data encryption needs
 - COPPA compliance requirements
 - Privacy considerations
+}
 
-## Testing Requirements
+## 🧪 Testing Requirements
+${TESTING_REQUIREMENTS:
 - Unit test scenarios
 - Widget test requirements
 - Integration test flows
 - Performance test criteria
 - Security test requirements
+}
+
+## 📈 Agent Progress Overview
+
+### 📋 PO Agent (Phoenix) - Requirements Analysis
+**Status**: ${PO_STATUS:pending} | **Progress**: ${PO_PROGRESS:0}%
+**Tasks**: ${PO_TASK_COUNT:0}/5 | **Last Activity**: ${PO_LAST_ACTIVITY:Not started}
+
+### 🎨 UI Agent (Aria) - Presentation Layer  
+**Status**: ${UI_STATUS:pending} | **Progress**: ${UI_PROGRESS:0}%
+**Tasks**: ${UI_TASK_COUNT:0}/5 | **Last Activity**: ${UI_LAST_ACTIVITY:Not started}
+
+### 🔄 Cubit Agent (Sage) - State Management
+**Status**: ${CUBIT_STATUS:pending} | **Progress**: ${CUBIT_PROGRESS:0}%
+**Tasks**: ${CUBIT_TASK_COUNT:0}/5 | **Last Activity**: ${CUBIT_LAST_ACTIVITY:Not started}
+
+### 🏗️ Domain Agent (Atlas) - Business Logic
+**Status**: ${DOMAIN_STATUS:pending} | **Progress**: ${DOMAIN_PROGRESS:0}%
+**Tasks**: ${DOMAIN_TASK_COUNT:0}/5 | **Last Activity**: ${DOMAIN_LAST_ACTIVITY:Not started}
+
+### 📊 Data Agent (Nova) - Data Layer
+**Status**: ${DATA_STATUS:pending} | **Progress**: ${DATA_PROGRESS:0}%
+**Tasks**: ${DATA_TASK_COUNT:0}/5 | **Last Activity**: ${DATA_LAST_ACTIVITY:Not started}
+
+### 🔒 Security Agent (Guardian) - Security & Compliance
+**Status**: ${SECURITY_STATUS:pending} | **Progress**: ${SECURITY_PROGRESS:0}%
+**Tasks**: ${SECURITY_TASK_COUNT:0}/5 | **Last Activity**: ${SECURITY_LAST_ACTIVITY:Not started}
+
+### 🧪 Test Agent (Trinity) - Quality Assurance
+**Status**: ${TEST_STATUS:pending} | **Progress**: ${TEST_PROGRESS:0}%
+**Tasks**: ${TEST_TASK_COUNT:0}/5 | **Last Activity**: ${TEST_LAST_ACTIVITY:Not started}
 
-## Definition of Done
+### ✅ Integration Validator - System Integration
+**Status**: ${INTEGRATION_STATUS:pending} | **Progress**: ${INTEGRATION_PROGRESS:0}%
+**Tasks**: ${INTEGRATION_TASK_COUNT:0}/5 | **Last Activity**: ${INTEGRATION_LAST_ACTIVITY:Not started}
+
+## 🚦 Quality Gates Status
+
+- [ ] **Requirements Gate**: ${QG_REQUIREMENTS:❌ Not Started}
+- [ ] **UI Gate**: ${QG_UI:❌ Not Started}
+- [ ] **State Gate**: ${QG_STATE:❌ Not Started}
+- [ ] **Domain Gate**: ${QG_DOMAIN:❌ Not Started}
+- [ ] **Data Gate**: ${QG_DATA:❌ Not Started}
+- [ ] **Security Gate**: ${QG_SECURITY:❌ Not Started}
+- [ ] **Testing Gate**: ${QG_TESTING:❌ Not Started}
+- [ ] **Integration Gate**: ${QG_INTEGRATION:❌ Not Started}
+
+## 🎯 Definition of Done
 - [ ] All acceptance criteria met
-- [ ] UI implementation complete and responsive
-- [ ] State management implemented
-- [ ] Domain logic implemented
-- [ ] Data layer implemented
-- [ ] Security measures implemented
-- [ ] Tests implemented and passing (90%+ coverage)
+- [ ] UI implementation complete and responsive (${UI_PROGRESS:0}%)
+- [ ] State management implemented (${CUBIT_PROGRESS:0}%)
+- [ ] Domain logic implemented (${DOMAIN_PROGRESS:0}%)
+- [ ] Data layer implemented (${DATA_PROGRESS:0}%)
+- [ ] Security measures implemented (${SECURITY_PROGRESS:0}%)
+- [ ] Tests implemented and passing 90%+ coverage (${TEST_PROGRESS:0}%)
+- [ ] Integration validation complete (${INTEGRATION_PROGRESS:0}%)
 - [ ] Documentation updated
 - [ ] Code reviewed and approved
 - [ ] Performance requirements met
+- [ ] COPPA compliance verified
+
+## 🔄 Parallel Execution Opportunities
+${PARALLEL_OPPORTUNITIES:None identified yet}
+
+## 🚨 Current Blockers
+${CURRENT_BLOCKERS:None}
+
+## 📝 Notes & Assumptions
+${ADDITIONAL_NOTES:Additional notes, assumptions, or constraints.}
+
+---
 
-## Notes
-Additional notes, assumptions, or constraints.
+**🤖 Managed by FeatureMaster** | **📄 Auto-updated by AppIQ Workflow System**  
+**📞 Commands**: Use `*help` with FeatureMaster for available commands  
+**💾 State File**: `docs/features/${FEATURE_NAME}_state.json`  
+**📋 Tasks**: `docs/tasks/${FEATURE_NAME}_tasks.md`  
+**📈 History**: `docs/tasks/${FEATURE_NAME}_history.md`

package/templates/additional_cubit_req.md

@@ -1,357 +0,0 @@
-# Additional Cubit Requirements - State Management Integration
-
-This template defines additional state management requirements, provider setup, and integration patterns for your feature.
-
-## State Management Architecture
-
-### Cubit Integration Pattern
-```dart
-// Feature-specific state management structure
-lib/features/{feature}/presentation/cubit/
-├── {feature}_cubit.dart           // Main cubit implementation
-├── {feature}_state.dart           // State definitions
-└── {feature}_event.dart           // Events (if using BLoC pattern)
-```
-
-### Global State Dependencies
-- [ ] Authentication state integration
-- [ ] User role state management  
-- [ ] Theme/settings state access
-- [ ] Navigation state coordination
-- [ ] Network connectivity state
-- [ ] Offline/online state management
-
-## Provider Setup Requirements
-
-### Main App Provider Configuration
-```dart
-// Add to main.dart MultiBlocProvider
-MultiBlocProvider(
-  providers: [
-    // Existing providers...
-    BlocProvider<{Feature}Cubit>(
-      create: (context) => GetIt.instance<{Feature}Cubit>(),
-    ),
-    // Additional feature dependencies...
-  ],
-  child: MyApp(),
-)
-```
-
-### Dependency Injection Setup
-```dart
-// Add to dependency injection configuration
-void configureDependencies() {
-  // Repository registration
-  getIt.registerLazySingleton<{Feature}Repository>(
-    () => {Feature}RepositoryImpl(
-      remoteDataSource: getIt(),
-      localDataSource: getIt(),
-      networkInfo: getIt(),
-    ),
-  );
-
-  // Use case registration
-  getIt.registerLazySingleton(() => Get{Feature}UseCase(getIt()));
-  getIt.registerLazySingleton(() => Create{Feature}UseCase(getIt()));
-  getIt.registerLazySingleton(() => Update{Feature}UseCase(getIt()));
-  getIt.registerLazySingleton(() => Delete{Feature}UseCase(getIt()));
-
-  // Cubit registration
-  getIt.registerFactory<{Feature}Cubit>(
-    () => {Feature}Cubit(
-      get{Feature}UseCase: getIt(),
-      create{Feature}UseCase: getIt(),
-      update{Feature}UseCase: getIt(),
-      delete{Feature}UseCase: getIt(),
-    ),
-  );
-}
-```
-
-## State Initialization Requirements
-
-### Initial State Setup
-```dart
-class {Feature}Cubit extends Cubit<{Feature}State> {
-  {Feature}Cubit({
-    required this.get{Feature}UseCase,
-    required this.create{Feature}UseCase,
-    required this.update{Feature}UseCase,
-    required this.delete{Feature}UseCase,
-  }) : super(const {Feature}State.initial());
-
-  // Initialize feature data on cubit creation
-  Future<void> initialize() async {
-    emit(state.copyWith(status: {Feature}Status.loading));
-    
-    try {
-      final result = await get{Feature}UseCase.call(NoParams());
-      result.fold(
-        (failure) => emit(state.copyWith(
-          status: {Feature}Status.error,
-          errorMessage: failure.message,
-        )),
-        (data) => emit(state.copyWith(
-          status: {Feature}Status.loaded,
-          items: data,
-        )),
-      );
-    } catch (e) {
-      emit(state.copyWith(
-        status: {Feature}Status.error,
-        errorMessage: 'Unexpected error occurred',
-      ));
-    }
-  }
-}
-```
-
-### Widget Integration Pattern
-```dart
-class {Feature}Page extends StatefulWidget {
-  @override
-  _State createState() => _State();
-}
-
-class _State extends State<{Feature}Page> {
-  late {Feature}Cubit cubit;
-
-  @override
-  void initState() {
-    super.initState();
-    cubit = context.read<{Feature}Cubit>();
-    // Initialize cubit data
-    cubit.initialize();
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    return BlocConsumer<{Feature}Cubit, {Feature}State>(
-      listener: (context, state) {
-        // Handle side effects (navigation, snackbars, etc.)
-        if (state.status == {Feature}Status.error) {
-          ScaffoldMessenger.of(context).showSnackBar(
-            SnackBar(content: Text(state.errorMessage ?? 'Error occurred')),
-          );
-        }
-      },
-      builder: (context, state) {
-        return Scaffold(
-          body: _buildBody(state),
-        );
-      },
-    );
-  }
-}
-```
-
-## Common Integration Issues & Solutions
-
-### Issue 1: Cubit Not Initialized
-**Problem**: `BlocProvider.of() called with a context that does not contain a Cubit`
-**Solution**:
-```dart
-// Ensure proper provider hierarchy
-MaterialApp(
-  home: MultiBlocProvider(
-    providers: [
-      BlocProvider<{Feature}Cubit>(
-        create: (context) => GetIt.instance<{Feature}Cubit>(),
-      ),
-    ],
-    child: {Feature}Page(),
-  ),
-)
-```
-
-### Issue 2: Duplicate Cubit Registration
-**Problem**: Multiple registrations of the same cubit type
-**Solution**:
-```dart
-// Use registerFactory for cubits (new instance per request)
-getIt.registerFactory<{Feature}Cubit>(() => {Feature}Cubit(...));
-
-// Or check if already registered
-if (!getIt.isRegistered<{Feature}Cubit>()) {
-  getIt.registerFactory<{Feature}Cubit>(() => {Feature}Cubit(...));
-}
-```
-
-### Issue 3: State Not Persisting Across Navigation
-**Problem**: State resets when navigating between screens
-**Solution**:
-```dart
-// Use singleton registration for state that should persist
-getIt.registerLazySingleton<{Feature}Cubit>(() => {Feature}Cubit(...));
-
-// Or use global provider at app level
-class MyApp extends StatelessWidget {
-  @override
-  Widget build(BuildContext context) {
-    return MultiBlocProvider(
-      providers: [
-        BlocProvider<{Feature}Cubit>(
-          create: (context) => GetIt.instance<{Feature}Cubit>(),
-        ),
-      ],
-      child: MaterialApp(...),
-    );
-  }
-}
-```
-
-## Cross-Feature State Communication
-
-### Feature-to-Feature State Updates
-```dart
-class {Feature}Cubit extends Cubit<{Feature}State> {
-  final AuthenticationCubit authCubit;
-  final UserRoleCubit userRoleCubit;
-  late StreamSubscription authSubscription;
-
-  {Feature}Cubit({
-    required this.authCubit,
-    required this.userRoleCubit,
-    // ... other dependencies
-  }) : super(const {Feature}State.initial()) {
-    // Listen to authentication changes
-    authSubscription = authCubit.stream.listen((authState) {
-      if (authState is! AuthenticatedState) {
-        // Clear feature data on logout
-        emit(const {Feature}State.initial());
-      }
-    });
-  }
-
-  @override
-  Future<void> close() {
-    authSubscription.cancel();
-    return super.close();
-  }
-}
-```
-
-### Global State Access Pattern
-```dart
-// Access other cubits from within a cubit
-void updateBasedOnUserRole() {
-  final userRole = userRoleCubit.state.role;
-  
-  switch (userRole) {
-    case UserRole.admin:
-      loadAdminData();
-      break;
-    case UserRole.manager:
-      loadManagerData();
-      break;
-    case UserRole.user:
-      loadUserData();
-      break;
-  }
-}
-```
-
-## Performance Optimization
-
-### Selective State Updates
-```dart
-// Use copyWith efficiently to avoid unnecessary rebuilds
-emit(state.copyWith(
-  status: {Feature}Status.loading,
-  // Only update changed fields
-));
-
-// Use state comparison to prevent duplicate emissions
-void updateItems(List<{Entity}> newItems) {
-  if (!listEquals(state.items, newItems)) {
-    emit(state.copyWith(items: newItems));
-  }
-}
-```
-
-### Memory Management
-```dart
-class {Feature}Cubit extends Cubit<{Feature}State> {
-  final List<StreamSubscription> _subscriptions = [];
-
-  void addSubscription(StreamSubscription subscription) {
-    _subscriptions.add(subscription);
-  }
-
-  @override
-  Future<void> close() {
-    // Cancel all subscriptions
-    for (final subscription in _subscriptions) {
-      subscription.cancel();
-    }
-    _subscriptions.clear();
-    return super.close();
-  }
-}
-```
-
-## Testing Integration
-
-### Cubit Testing Setup
-```dart
-// Test setup with proper mocking
-class MockAuthCubit extends MockCubit<AuthState> implements AuthCubit {}
-class MockUserRoleCubit extends MockCubit<UserRoleState> implements UserRoleCubit {}
-
-void main() {
-  late {Feature}Cubit cubit;
-  late MockAuthCubit mockAuthCubit;
-  late MockUserRoleCubit mockUserRoleCubit;
-
-  setUp(() {
-    mockAuthCubit = MockAuthCubit();
-    mockUserRoleCubit = MockUserRoleCubit();
-    
-    cubit = {Feature}Cubit(
-      authCubit: mockAuthCubit,
-      userRoleCubit: mockUserRoleCubit,
-      // ... other dependencies
-    );
-  });
-
-  tearDown(() {
-    cubit.close();
-  });
-}
-```
-
-## Integration Checklist
-
-### Provider Setup
-- [ ] Cubit registered in dependency injection
-- [ ] Provider added to MultiBlocProvider
-- [ ] Dependencies properly injected
-- [ ] Initialization logic implemented
-
-### State Management
-- [ ] Initial state properly defined
-- [ ] State transitions implemented
-- [ ] Error handling added
-- [ ] Loading states managed
-
-### Cross-Feature Integration
-- [ ] Authentication state integration
-- [ ] User role state access
-- [ ] Global state dependencies resolved
-- [ ] Navigation state coordination
-
-### Performance & Memory
-- [ ] Efficient state updates implemented
-- [ ] Memory leaks prevented (subscriptions canceled)
-- [ ] Unnecessary rebuilds minimized
-- [ ] State persistence strategy defined
-
-### Testing
-- [ ] Unit tests for cubit logic
-- [ ] Integration tests with providers
-- [ ] Mock implementations for dependencies
-- [ ] Error scenario testing
-
-## Notes
-Add any feature-specific state management requirements, custom integration patterns, or special initialization needs.