appiq-solution 1.4.8 → 1.5.0

package/bmad-core/tasks/intelligent-epic-creation.md

@@ -1,234 +0,0 @@
-# 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

package/bmad-core/tasks/smart-project-analysis.md

@@ -1,289 +0,0 @@
-# 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