appiq-solution 1.6.5 → 1.7.1

package/README.md

@@ -90,61 +90,85 @@ Since you already have documented architecture, this is the perfect starting poi
 - Creates a "Brownfield Analysis" with recommendations
 - Defines how new features fit into your existing structure
 
-### 3. Plan Livestream Feature
+### 3. Start the Master Flutter Workflow
 
-Now the Scrum Master comes into play:
+Now use the **Master Flutter Orchestrator** to automatically handle everything:
 
-```bash
-@sm
-```
-
-**The SM will ask you:**
-- Which specific livestream functions are needed
-- Which UI components are required
-- How the feature integrates into existing navigation
-- Which backend endpoints are needed
-
-### 4. Automatic Flutter Workflow Starts
-
-Once the story is defined, the `flutter-ui-first-development` workflow automatically starts:
-
-**Phase 1: UI Design (Maya - flutter-ui-agent)**
 ```
-"How should the livestream UI look?"
-"Which widgets do we need (Player, Chat, Controls)?"
-"Where in existing navigation will it be integrated?"
+/flutter-init-agent - Erstelle eine TikTok-ähnliche Livestream-UI mit:
+- Vertical Video Player (Vollbild)
+- Like Button mit Animation
+- Share Button
+- Kommentar-System (Real-time)
+- Viewer Counter
+- Follow Button
+
+Target Folder: lib/features/livestream/
+Screenshots: [Optional: Füge Screenshots oder Mockups hinzu]
 ```
 
-Maya creates:
-- Livestream pages (`livestream_page.dart`, `livestream_detail_page.dart`)
-- Custom widgets (`livestream_player_widget.dart`, `chat_widget.dart`)
-- Localization keys for all texts
-- Integration into your existing navigation
-
-**Phase 2: State Management (Alex - flutter-cubit-agent)**
-
-Alex implements:
-- `LivestreamCubit` with States (initial, loading, streaming, error)
-- `LivestreamState` class with all required data
-- Error handling for connection drops
-- Integration with your existing state patterns
-
-**Phase 3: Business Logic (Jordan - flutter-domain-agent)**
-
-Jordan creates:
-- `LivestreamEntity` (Stream-ID, URL, Viewer-Count, etc.)
-- `StartLivestreamUseCase`, `StopLivestreamUseCase`
-- `LivestreamRepository` Interface
-- Business validation (e.g., permission checks)
-
-**Phase 4: Data Layer (Sam - flutter-data-agent)**
-
-Sam implements:
-- `LivestreamRepositoryImpl`
-- `LivestreamRemoteDataSource` (API calls)
-- `LivestreamLocalDataSource` (caching)
-- `LivestreamModel` with JSON serialization
-- WebSocket integration for real-time chat
+### 4. Automatic End-to-End Workflow
+
+The `flutter-init-agent` will **automatically orchestrate the complete development process**:
+
+#### **🎯 Phase 1: Automatic Analysis**
+- **Scans your existing codebase** using `npx appiq-solution flatten`
+- **Analyzes architecture patterns** (routing, state management, DI)
+- **Identifies integration points** with your existing features
+- **Plans implementation strategy** for the new feature
+
+#### **🏗️ Phase 2: Team Orchestration**
+The agent automatically triggers this sequence:
+
+**2.1 Product Owner (@po)**
+- Creates user stories, epics, and acceptance criteria
+- Defines feature breakdown and requirements
+
+**2.2 Architect (@architect)**  
+- Analyzes existing codebase structure
+- Plans integration with current architecture
+- Defines backend requirements (Supabase tables, etc.)
+- Creates implementation guidelines
+
+**2.3 UI Development (@flutter-ui-agent)**
+- Creates pages and navigation integration
+- Implements custom widgets and animations
+- Ensures responsive design and accessibility
+
+**2.4 State Management (@flutter-cubit-agent)**
+- Implements Cubit/BLoC patterns matching your existing setup
+- Handles error states and loading management
+- Integrates with current state management
+
+**2.5 Business Logic (@flutter-domain-agent)**
+- Creates entities, use cases, and business rules
+- Implements validation and business logic
+- Defines repository interfaces
+
+**2.6 Data Layer (@flutter-data-agent)**
+- Implements repository pattern
+- Creates API integration and caching
+- Handles data serialization and persistence
+
+**2.7 Backend Integration (MCP Supabase/Firebase)**
+- Creates database tables and relationships
+- Sets up authentication and security rules
+- Implements real-time features
+
+**2.8 Quality Assurance (@qa)**
+- Performs code review against existing patterns
+- Implements comprehensive testing strategy
+- Validates architecture consistency
+
+**2.9 Security Audit (@flutter-security-agent)**
+- Checks for security vulnerabilities
+- Validates API key protection
+- Ensures data privacy compliance
+
+**2.10 Git Integration**
+- Commits changes with proper messages
+- Creates feature branches
+- Prepares for code review
 
 ### 5. Backend Integration
 
@@ -161,27 +185,49 @@ After each phase runs automatically:
 - Testing (Unit, Widget, Integration tests)
 - Security validation
 
-## 🔄 Your Concrete Workflow
+## 🔄 Your Complete Workflow
 
-**One-time setup:**
+### **One-time setup:**
 ```bash
 npx appiq-solution  # Choose appiq-flutter-mobile-dev
-@architect          # Analyze existing architecture
+@architect          # Analyze existing architecture (optional)
 ```
 
-**For each new feature:**
-```bash
-@sm  # "Create story for [Feature-Name]"
-```
-- System runs automatically through all agents
-- You provide input/feedback at respective handoff points
-- At the end you have a fully implemented feature
-
-**In your IDE (Cursor, Claude, etc.):**
+### **For each new feature - Just one command:**
 ```
-@smart-launcher
+/flutter-init-agent - Erstelle ein Instagram-ähnliches Story Feature mit:
+- Vollbild Story Viewer
+- Progress Indicators  
+- Swipe Navigation
+- Story Creation (Foto/Video)
+- Story Archive
+- View Analytics
+
+Target Folder: lib/features/stories/
+Backend: Supabase (stories table, media storage)
+Integration: Mit bestehendem User System
 ```
 
+### **What happens automatically:**
+✅ **Complete codebase analysis** and architecture understanding  
+✅ **Automatic team orchestration** through all specialized agents  
+✅ **End-to-end implementation** from UI to backend  
+✅ **Quality assurance** and security validation  
+✅ **Git integration** with proper commits  
+
+**You only need to:**
+- Provide the initial feature description
+- Give feedback when agents ask for clarification
+- Review and approve the final implementation
+
+### **Available Flutter Agents:**
+- `/flutter-init-agent` - Master orchestrator for complete features
+- `/flutter-ui-agent` - UI components and design
+- `/flutter-cubit-agent` - State management
+- `/flutter-domain-agent` - Business logic
+- `/flutter-data-agent` - Data layer and APIs
+- `/flutter-security-agent` - Security auditing
+
 ## 🗂️ Codebase Context Management
 
 Automatic context export after every feature/milestone:

package/bmad-core/core-config.yaml

@@ -1,20 +1,184 @@
 markdownExploder: true
+
+# Standard PRD Configuration
 prd:
   prdFile: docs/prd.md
   prdVersion: v4
   prdSharded: true
   prdShardedLocation: docs/prd
   epicFilePattern: epic-{n}*.md
+  
+  # Enhanced PRD Pattern Recognition
+  prdFilePattern: "*_prd.md"
+  requirementsFilePattern: "*_requirements.md"
+  featureFilePattern: "*_feature.md"
+  
+  # Auto-Detection Settings
+  autoPrdDetection: true
+  autoPrdSharding: true
+  autoPrdWorkflow: true
+
 architecture:
   architectureFile: docs/architecture.md
   architectureVersion: v4
   architectureSharded: true
   architectureShardedLocation: docs/architecture
+
+# Smart Analysis Configuration
+smartAnalysis:
+  enabled: true
+  
+  # Codebase Analysis
+  codebaseAnalysis:
+    enabled: true
+    scanDirectories:
+      - "lib/features/"
+      - "lib/shared/"
+      - "lib/core/"
+    
+    # Similarity Detection
+    similarityThreshold: 0.6  # 60% similarity to suggest reuse
+    keywordMatching: true
+    patternMatching: true
+    
+    # Code Reuse Detection 
+    reuseAnalysis:
+      widgets: "lib/shared/widgets/"
+      services: "lib/shared/services/"
+      utils: "lib/shared/utils/"
+      patterns: "lib/features/*/presentation/"
+  
+  # UI Reference Processing
+  uiReferenceProcessing:
+    enabled: true
+    assetDirectories:
+      - "assets/images/"
+      - "assets/icons/"
+      - "assets/mockups/"
+    supportedFormats: ["png", "jpg", "svg", "pdf"]
+    autoCreateDirectories: true
+  
+  # Architect Consultation
+  architectConsultation:
+    enabled: true
+    triggers:
+      - complexityThreshold: "high"
+      - conflictingPatterns: true
+      - noExistingPatterns: true
+      - crossFeatureDependencies: true
+    
+    analysisDepth: "deep"  # shallow, medium, deep
+    
+  # Integration Analysis
+  integrationAnalysis:
+    enabled: true
+    checkExistingFiles: true
+    validatePaths: true
+    conflictDetection: true
+    dependencyMapping: true
+
+# Auto-Workflow Configuration
+autoWorkflow:
+  enabled: true
+  
+  # Scan Configuration
+  scanDirectories: 
+    - "docs/"
+    - "features/"
+    - "./"
+    - "requirements/"
+  
+  # File Pattern Triggers
+  triggerPatterns:
+    - "*_prd.md"
+    - "*_requirements.md" 
+    - "*_feature.md"
+    - "*_spec.md"
+  
+  # Workflow Automation
+  autoSharding: true
+  autoStoryGeneration: true
+  autoArchitectConsultation: true
+  
+  # Flutter-Specific Settings
+  flutterIntegration:
+    enabled: true
+    autoDetectFlutterProject: true
+    applyFlutterPatterns: true
+    useCleanArchitecture: true
+    defaultStateManagement: "cubit"
+
+# Development Configuration
 customTechnicalDocuments: null
 devLoadAlwaysFiles:
   - docs/architecture/coding-standards.md
   - docs/architecture/tech-stack.md
   - docs/architecture/source-tree.md
+  - bmad-core/data/mandatory-development-rules.md
+  - expansion-packs/appiq-flutter-mobile-dev/data/flutter-development-guidelines.md
+  
 devDebugLog: .ai/debug-log.md
 devStoryLocation: docs/stories
-slashPrefix: BMad
+
+# Enhanced Development Settings
+devEnhancements:
+  codeReuseValidation: true
+  existingComponentScan: true
+  architecturalComplianceCheck: true
+  performancePatternValidation: true
+
+# MANDATORY DEVELOPMENT RULES ENFORCEMENT
+mandatoryRules:
+  enabled: true
+  enforceStandardWorkflow: true
+  enforceQualityGates: true
+  enforcePreCodingChecklist: true
+  
+  # Standard Workflow Enforcement
+  standardWorkflow:
+    requirePlan: true
+    requireVerification: true
+    requireExplanations: true
+    requireSimpleChanges: true
+    requireReview: true
+    requireCommits: true
+  
+  # Quality Gates Enforcement (ALL 5 MUST PASS!)
+  qualityGates:
+    DRY: true              # No code duplication
+    Readable: true         # Self-documenting code
+    Maintainable: true     # Clean Architecture
+    Performant: true       # Optimized implementation
+    Testable: true         # Comprehensive tests
+  
+  # Flutter-Specific Rules
+  flutterRules:
+    noStaticText: true           # All text must use AppLocalizations
+    cleanArchitecture: true     # Presentation → Domain ← Data
+    cubitStateManagement: true  # Use Cubit patterns
+    repositoryPattern: true     # Implement Repository pattern
+    dependencyInjection: true   # Use GetIt
+    
+  # Code Integration Rules
+  codeIntegration:
+    checkExistingFirst: true    # Always check existing code first
+    reuseComponents: true       # Reuse shared components
+    followPatterns: true        # Follow existing patterns
+    extendNotDuplicate: true    # Extend instead of duplicate
+  
+  # Failure Conditions (NEVER ALLOWED!)
+  failureConditions:
+    staticTextInUI: true        # Instant failure
+    codeDuplication: true       # Instant failure
+    patternBreaking: true       # Instant failure
+    missingTests: true          # Instant failure
+    architectureViolation: true # Instant failure
+
+# Reporting Configuration
+reporting:
+  generateAnalysisReports: true
+  reportLocation: "docs/analysis/"
+  includeReuseRecommendations: true
+  includeArchitecturalSuggestions: true
+
+slashPrefix: bmad

package/docs/onboarding_prd.md

@@ -0,0 +1,93 @@
+# Onboarding Product Requirements Document
+
+## 1. Overview
+This document outlines the requirements for the **User Onboarding** feature in our Flutter mobile application. The onboarding flow should guide new users through the app's key features and help them get started quickly.
+
+## 2. Feature Description
+A comprehensive onboarding experience consisting of:
+- Welcome screen with app introduction
+- Feature highlights (3-4 key screens)
+- Account setup/login integration
+- Permissions requests (notifications, location, etc.)
+- Tutorial completion confirmation
+
+The onboarding should be skippable and only shown to first-time users.
+
+## 3. Functional Requirements
+- FR1: Display welcome screen with app logo and tagline
+- FR2: Show 3-4 feature highlight screens with illustrations
+- FR3: Integrate with existing authentication system
+- FR4: Request necessary permissions (push notifications, location)
+- FR5: Allow users to skip onboarding at any point
+- FR6: Remember onboarding completion status
+- FR7: Provide "Get Started" button to proceed to main app
+- FR8: Support both light and dark themes
+
+## 4. Non-Functional Requirements
+- NFR1: Performance - Smooth page transitions with animations
+- NFR2: Accessibility - Support for screen readers and large text
+- NFR3: Localization - Support for all app languages
+- NFR4: Security - No sensitive data collection during onboarding
+- NFR5: Analytics - Track onboarding completion rates
+
+## 5. User Stories
+- As a new user, I want to understand what the app does so that I can decide to continue using it.
+- As a new user, I want to see key features highlighted so that I know what's available.
+- As a new user, I want to quickly set up my account so that I can start using the app.
+- As a returning user, I want to skip onboarding so that I can access the app immediately.
+- As a user with accessibility needs, I want the onboarding to be screen reader friendly.
+
+## 6. Implementation Details (Optional - for Brownfield Projects)
+**Implementation Path:** `lib/features/onboarding`
+*   **Rationale**: New standalone feature that doesn't interfere with existing authentication flow. Clean separation from other features.
+*   **Integration Points**:
+    - `lib/main.dart` (for routing - add onboarding route)
+    - `lib/core/di/injection_container.dart` (for dependency injection)
+    - `lib/features/auth/presentation/cubit/auth_cubit.dart` (check if user is first-time)
+    - `lib/shared/widgets/base_scaffold.dart` (for consistent styling)
+    - `lib/core/storage/local_storage_service.dart` (store onboarding completion)
+*   **Existing Components to Check for Reuse**:
+    - `lib/shared/widgets/custom_button.dart` (for CTA buttons)
+    - `lib/shared/widgets/loading_widget.dart` (for loading states)
+    - `lib/shared/utils/theme_helper.dart` (for theme-aware styling)
+    - `lib/shared/widgets/animated_page_view.dart` (if exists for page transitions)
+    - `lib/features/auth/data/models/user_model.dart` (for user state)
+    - `lib/core/error/failures.dart` (for error handling)
+
+## 7. UI Reference (Optional)
+*   **Mockups/Wireframes**:
+    - `docs/ui/mockups/onboarding_welcome_screen.png`
+    - `docs/ui/mockups/onboarding_feature_highlights.png`
+    - `docs/ui/mockups/onboarding_permissions.png`
+    - `docs/ui/mockups/onboarding_completion.png`
+*   **Design Notes**: 
+    - Use app's primary brand colors
+    - Consistent with Material 3 design system
+    - Smooth page transitions with fade/slide animations
+    - Minimum 44pt touch targets for accessibility
+
+## 8. Acceptance Criteria
+- AC1: New users see onboarding flow on first app launch
+- AC2: Returning users bypass onboarding and go directly to main app
+- AC3: Users can skip onboarding at any point using "Skip" button
+- AC4: All text is localized and supports app's languages
+- AC5: Onboarding works in both light and dark themes
+- AC6: Page transitions are smooth with appropriate animations
+- AC7: Permissions are requested at appropriate moments
+- AC8: Onboarding completion is persisted locally
+- AC9: Analytics events are fired for onboarding steps
+- AC10: Accessibility features work correctly (screen readers, large text)
+
+## 9. Dependencies
+- Existing authentication system integration
+- Local storage service for persistence
+- Analytics service for tracking
+- Permission handling service
+- Theme system integration
+
+## 10. Future Scope
+- A/B testing different onboarding flows
+- Personalized onboarding based on user type
+- Interactive tutorials for complex features
+- Video introductions for key features
+- Progressive onboarding (show features when relevant)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appiq-solution",
-  "version": "1.6.5",
+  "version": "1.7.1",
   "description": "APPIQ SOLUTION: Flutter Mobile Development Extension for BMAD Method",
   "main": "tools/cli.js",
   "bin": {

package/tools/installer/lib/ide-setup.js

@@ -85,6 +85,15 @@ class IdeSetup extends BaseIdeSetup {
   }
 
   async setupClaudeCode(installDir, selectedAgent) {
+    // First try Claude IDE native format
+    const claudeNativeSuccess = await this.setupClaudeIdeNative(installDir);
+    if (claudeNativeSuccess) {
+      return true;
+    }
+
+    // Fallback to legacy format
+    console.log(chalk.yellow("⚠️  Claude IDE native agents not found, using legacy format"));
+    
     // Setup bmad-core commands
     const coreSlashPrefix = await this.getCoreSlashPrefix(installDir);
     const coreAgents = selectedAgent ? [selectedAgent] : await this.getCoreAgentIds(installDir);
@@ -119,6 +128,53 @@ class IdeSetup extends BaseIdeSetup {
     return true;
   }
 
+  async setupClaudeIdeNative(installDir) {
+    const claudeDir = path.join(installDir, ".claude");
+    const agentsDir = path.join(claudeDir, "agents");
+    
+    // Check if we have the converted agents - look in the source directory (where this installer is located)
+    const installerDir = path.dirname(path.dirname(path.dirname(__dirname))); // Go up from tools/installer/lib to project root
+    const sourceAgentsDir = path.join(installerDir, ".claude", "agents");
+    
+    if (!(await fileManager.pathExists(sourceAgentsDir))) {
+      return false; // No native agents found
+    }
+
+    // Ensure .claude/agents directory exists (Claude IDE native format)
+    await fileManager.ensureDirectory(claudeDir);
+    await fileManager.ensureDirectory(agentsDir);
+
+    console.log(chalk.blue("🚀 Installing Claude IDE native agents..."));
+    
+    // Copy all converted agents
+    const fs = require('fs-extra');
+    const agentFiles = await fs.readdir(sourceAgentsDir);
+    let installedCount = 0;
+    
+    for (const agentFile of agentFiles) {
+      // Skip directories and hidden files, only copy agent files (without .md extension)
+      if (agentFile.startsWith('.') || agentFile.includes('.')) {
+        continue;
+      }
+      
+      const sourcePath = path.join(sourceAgentsDir, agentFile);
+      const stats = await fs.stat(sourcePath);
+      
+      if (stats.isFile()) {
+        const targetPath = path.join(agentsDir, agentFile);
+        
+        const agentContent = await fileManager.readFile(sourcePath);
+        await fileManager.writeFile(targetPath, agentContent);
+        
+        console.log(chalk.green(`✓ Installed Claude IDE agent: ${agentFile}`));
+        installedCount++;
+      }
+    }
+
+    console.log(chalk.green(`✅ Claude IDE native setup completed (${installedCount} agents installed)`));
+    return true;
+  }
+
   async setupClaudeCodeForPackage(installDir, packageName, slashPrefix, agentIds, taskIds, rootPath) {
     const commandsBaseDir = path.join(installDir, ".claude", "commands", slashPrefix);
     const agentsDir = path.join(commandsBaseDir, "agents");