appiq-solution 1.4.3 → 1.4.4

package/bmad-core/tasks/facilitate-brainstorming-session.md

@@ -0,0 +1,136 @@
+---
+docOutputLocation: docs/brainstorming-session-results.md
+template: "{root}/templates/brainstorming-output-tmpl.yaml"
+---
+
+# Facilitate Brainstorming Session Task
+
+Facilitate interactive brainstorming sessions with users. Be creative and adaptive in applying techniques.
+
+## Process
+
+### Step 1: Session Setup
+
+Ask 4 context questions (don't preview what happens next):
+
+1. What are we brainstorming about?
+2. Any constraints or parameters?
+3. Goal: broad exploration or focused ideation?
+4. Do you want a structured document output to reference later? (Default Yes)
+
+### Step 2: Present Approach Options
+
+After getting answers to Step 1, present 4 approach options (numbered):
+
+1. User selects specific techniques
+2. Analyst recommends techniques based on context
+3. Random technique selection for creative variety
+4. Progressive technique flow (start broad, narrow down)
+
+### Step 3: Execute Techniques Interactively
+
+**KEY PRINCIPLES:**
+
+- **FACILITATOR ROLE**: Guide user to generate their own ideas through questions, prompts, and examples
+- **CONTINUOUS ENGAGEMENT**: Keep user engaged with chosen technique until they want to switch or are satisfied
+- **CAPTURE OUTPUT**: If (default) document output requested, capture all ideas generated in each technique section to the document from the beginning.
+
+**Technique Selection:**
+If user selects Option 1, present numbered list of techniques from the brainstorming-techniques data file. User can select by number..
+
+**Technique Execution:**
+
+1. Apply selected technique according to data file description
+2. Keep engaging with technique until user indicates they want to:
+   - Choose a different technique
+   - Apply current ideas to a new technique  
+   - Move to convergent phase
+   - End session
+
+**Output Capture (if requested):**
+For each technique used, capture:
+
+- Technique name and duration
+- Key ideas generated by user
+- Insights and patterns identified
+- User's reflections on the process
+
+### Step 4: Session Flow
+
+1. **Warm-up** (5-10 min) - Build creative confidence
+2. **Divergent** (20-30 min) - Generate quantity over quality
+3. **Convergent** (15-20 min) - Group and categorize ideas
+4. **Synthesis** (10-15 min) - Refine and develop concepts
+
+### Step 5: Document Output (if requested)
+
+Generate structured document with these sections:
+
+**Executive Summary**
+
+- Session topic and goals
+- Techniques used and duration
+- Total ideas generated
+- Key themes and patterns identified
+
+**Technique Sections** (for each technique used)
+
+- Technique name and description
+- Ideas generated (user's own words)
+- Insights discovered
+- Notable connections or patterns
+
+**Idea Categorization**
+
+- **Immediate Opportunities** - Ready to implement now
+- **Future Innovations** - Requires development/research
+- **Moonshots** - Ambitious, transformative concepts
+- **Insights & Learnings** - Key realizations from session
+
+**Action Planning**
+
+- Top 3 priority ideas with rationale
+- Next steps for each priority
+- Resources/research needed
+- Timeline considerations
+
+**Reflection & Follow-up**
+
+- What worked well in this session
+- Areas for further exploration
+- Recommended follow-up techniques
+- Questions that emerged for future sessions
+
+## Key Principles
+
+- **YOU ARE A FACILITATOR**: Guide the user to brainstorm, don't brainstorm for them (unless they request it persistently)
+- **INTERACTIVE DIALOGUE**: Ask questions, wait for responses, build on their ideas
+- **ONE TECHNIQUE AT A TIME**: Don't mix multiple techniques in one response
+- **CONTINUOUS ENGAGEMENT**: Stay with one technique until user wants to switch
+- **DRAW IDEAS OUT**: Use prompts and examples to help them generate their own ideas
+- **REAL-TIME ADAPTATION**: Monitor engagement and adjust approach as needed
+- Maintain energy and momentum
+- Defer judgment during generation
+- Quantity leads to quality (aim for 100 ideas in 60 minutes)
+- Build on ideas collaboratively
+- Document everything in output document
+
+## Advanced Engagement Strategies
+
+**Energy Management**
+
+- Check engagement levels: "How are you feeling about this direction?"
+- Offer breaks or technique switches if energy flags
+- Use encouraging language and celebrate idea generation
+
+**Depth vs. Breadth**
+
+- Ask follow-up questions to deepen ideas: "Tell me more about that..."
+- Use "Yes, and..." to build on their ideas
+- Help them make connections: "How does this relate to your earlier idea about...?"
+
+**Transition Management**
+
+- Always ask before switching techniques: "Ready to try a different approach?"
+- Offer options: "Should we explore this idea deeper or generate more alternatives?"
+- Respect their process and timing

package/bmad-core/tasks/generate-ai-frontend-prompt.md

@@ -0,0 +1,51 @@
+# Create AI Frontend Prompt Task
+
+## Purpose
+
+To generate a masterful, comprehensive, and optimized prompt that can be used with any AI-driven frontend development tool (e.g., Vercel v0, Lovable.ai, or similar) to scaffold or generate significant portions of a frontend application.
+
+## Inputs
+
+- Completed UI/UX Specification (`front-end-spec.md`)
+- Completed Frontend Architecture Document (`front-end-architecture`) or a full stack combined architecture such as `architecture.md`
+- Main System Architecture Document (`architecture` - for API contracts and tech stack to give further context)
+
+## Key Activities & Instructions
+
+### 1. Core Prompting Principles
+
+Before generating the prompt, you must understand these core principles for interacting with a generative AI for code.
+
+- **Be Explicit and Detailed**: The AI cannot read your mind. Provide as much detail and context as possible. Vague requests lead to generic or incorrect outputs.
+- **Iterate, Don't Expect Perfection**: Generating an entire complex application in one go is rare. The most effective method is to prompt for one component or one section at a time, then build upon the results.
+- **Provide Context First**: Always start by providing the AI with the necessary context, such as the tech stack, existing code snippets, and overall project goals.
+- **Mobile-First Approach**: Frame all UI generation requests with a mobile-first design mindset. Describe the mobile layout first, then provide separate instructions for how it should adapt for tablet and desktop.
+
+### 2. The Structured Prompting Framework
+
+To ensure the highest quality output, you MUST structure every prompt using the following four-part framework.
+
+1. **High-Level Goal**: Start with a clear, concise summary of the overall objective. This orients the AI on the primary task.
+   - _Example: "Create a responsive user registration form with client-side validation and API integration."_
+2. **Detailed, Step-by-Step Instructions**: Provide a granular, numbered list of actions the AI should take. Break down complex tasks into smaller, sequential steps. This is the most critical part of the prompt.
+   - _Example: "1. Create a new file named `RegistrationForm.js`. 2. Use React hooks for state management. 3. Add styled input fields for 'Name', 'Email', and 'Password'. 4. For the email field, ensure it is a valid email format. 5. On submission, call the API endpoint defined below."_
+3. **Code Examples, Data Structures & Constraints**: Include any relevant snippets of existing code, data structures, or API contracts. This gives the AI concrete examples to work with. Crucially, you must also state what _not_ to do.
+   - _Example: "Use this API endpoint: `POST /api/register`. The expected JSON payload is `{ "name": "string", "email": "string", "password": "string" }`. Do NOT include a 'confirm password' field. Use Tailwind CSS for all styling."_
+4. **Define a Strict Scope**: Explicitly define the boundaries of the task. Tell the AI which files it can modify and, more importantly, which files to leave untouched to prevent unintended changes across the codebase.
+   - _Example: "You should only create the `RegistrationForm.js` component and add it to the `pages/register.js` file. Do NOT alter the `Navbar.js` component or any other existing page or component."_
+
+### 3. Assembling the Master Prompt
+
+You will now synthesize the inputs and the above principles into a final, comprehensive prompt.
+
+1. **Gather Foundational Context**:
+   - Start the prompt with a preamble describing the overall project purpose, the full tech stack (e.g., Next.js, TypeScript, Tailwind CSS), and the primary UI component library being used.
+2. **Describe the Visuals**:
+   - If the user has design files (Figma, etc.), instruct them to provide links or screenshots.
+   - If not, describe the visual style: color palette, typography, spacing, and overall aesthetic (e.g., "minimalist", "corporate", "playful").
+3. **Build the Prompt using the Structured Framework**:
+   - Follow the four-part framework from Section 2 to build out the core request, whether it's for a single component or a full page.
+4. **Present and Refine**:
+   - Output the complete, generated prompt in a clear, copy-pasteable format (e.g., a large code block).
+   - Explain the structure of the prompt and why certain information was included, referencing the principles above.
+   - <important_note>Conclude by reminding the user that all AI-generated code will require careful human review, testing, and refinement to be considered production-ready.</important_note>

package/bmad-core/tasks/index-docs.md

@@ -0,0 +1,179 @@
+# Index Documentation Task
+
+## Purpose
+
+This task maintains the integrity and completeness of the `docs/index.md` file by scanning all documentation files and ensuring they are properly indexed with descriptions. It handles both root-level documents and documents within subfolders, organizing them hierarchically.
+
+## Task Instructions
+
+You are now operating as a Documentation Indexer. Your goal is to ensure all documentation files are properly cataloged in the central index with proper organization for subfolders.
+
+### Required Steps
+
+1. First, locate and scan:
+
+   - The `docs/` directory and all subdirectories
+   - The existing `docs/index.md` file (create if absent)
+   - All markdown (`.md`) and text (`.txt`) files in the documentation structure
+   - Note the folder structure for hierarchical organization
+
+2. For the existing `docs/index.md`:
+
+   - Parse current entries
+   - Note existing file references and descriptions
+   - Identify any broken links or missing files
+   - Keep track of already-indexed content
+   - Preserve existing folder sections
+
+3. For each documentation file found:
+
+   - Extract the title (from first heading or filename)
+   - Generate a brief description by analyzing the content
+   - Create a relative markdown link to the file
+   - Check if it's already in the index
+   - Note which folder it belongs to (if in a subfolder)
+   - If missing or outdated, prepare an update
+
+4. For any missing or non-existent files found in index:
+
+   - Present a list of all entries that reference non-existent files
+   - For each entry:
+     - Show the full entry details (title, path, description)
+     - Ask for explicit confirmation before removal
+     - Provide option to update the path if file was moved
+     - Log the decision (remove/update/keep) for final report
+
+5. Update `docs/index.md`:
+   - Maintain existing structure and organization
+   - Create level 2 sections (`##`) for each subfolder
+   - List root-level documents first
+   - Add missing entries with descriptions
+   - Update outdated entries
+   - Remove only entries that were confirmed for removal
+   - Ensure consistent formatting throughout
+
+### Index Structure Format
+
+The index should be organized as follows:
+
+```markdown
+# Documentation Index
+
+## Root Documents
+
+### [Document Title](./document.md)
+
+Brief description of the document's purpose and contents.
+
+### [Another Document](./another.md)
+
+Description here.
+
+## Folder Name
+
+Documents within the `folder-name/` directory:
+
+### [Document in Folder](./folder-name/document.md)
+
+Description of this document.
+
+### [Another in Folder](./folder-name/another.md)
+
+Description here.
+
+## Another Folder
+
+Documents within the `another-folder/` directory:
+
+### [Nested Document](./another-folder/document.md)
+
+Description of nested document.
+
+```
+
+### Index Entry Format
+
+Each entry should follow this format:
+
+```markdown
+### [Document Title](relative/path/to/file.md)
+
+Brief description of the document's purpose and contents.
+```
+
+### Rules of Operation
+
+1. NEVER modify the content of indexed files
+2. Preserve existing descriptions in index.md when they are adequate
+3. Maintain any existing categorization or grouping in the index
+4. Use relative paths for all links (starting with `./`)
+5. Ensure descriptions are concise but informative
+6. NEVER remove entries without explicit confirmation
+7. Report any broken links or inconsistencies found
+8. Allow path updates for moved files before considering removal
+9. Create folder sections using level 2 headings (`##`)
+10. Sort folders alphabetically, with root documents listed first
+11. Within each section, sort documents alphabetically by title
+
+### Process Output
+
+The task will provide:
+
+1. A summary of changes made to index.md
+2. List of newly indexed files (organized by folder)
+3. List of updated entries
+4. List of entries presented for removal and their status:
+   - Confirmed removals
+   - Updated paths
+   - Kept despite missing file
+5. Any new folders discovered
+6. Any other issues or inconsistencies found
+
+### Handling Missing Files
+
+For each file referenced in the index but not found in the filesystem:
+
+1. Present the entry:
+
+   ```markdown
+   Missing file detected:
+   Title: [Document Title]
+   Path: relative/path/to/file.md
+   Description: Existing description
+   Section: [Root Documents | Folder Name]
+
+   Options:
+
+   1. Remove this entry
+   2. Update the file path
+   3. Keep entry (mark as temporarily unavailable)
+
+   Please choose an option (1/2/3):
+   ```
+
+2. Wait for user confirmation before taking any action
+3. Log the decision for the final report
+
+### Special Cases
+
+1. **Sharded Documents**: If a folder contains an `index.md` file, treat it as a sharded document:
+
+   - Use the folder's `index.md` title as the section title
+   - List the folder's documents as subsections
+   - Note in the description that this is a multi-part document
+
+2. **README files**: Convert `README.md` to more descriptive titles based on content
+
+3. **Nested Subfolders**: For deeply nested folders, maintain the hierarchy but limit to 2 levels in the main index. Deeper structures should have their own index files.
+
+## Required Input
+
+Please provide:
+
+1. Location of the `docs/` directory (default: `./docs`)
+2. Confirmation of write access to `docs/index.md`
+3. Any specific categorization preferences
+4. Any files or directories to exclude from indexing (e.g., `.git`, `node_modules`)
+5. Whether to include hidden files/folders (starting with `.`)
+
+Would you like to proceed with documentation indexing? Please provide the required input above.

package/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

package/bmad-core/tasks/kb-mode-interaction.md

@@ -0,0 +1,75 @@
+# KB Mode Interaction Task
+
+## Purpose
+
+Provide a user-friendly interface to the BMad knowledge base without overwhelming users with information upfront.
+
+## Instructions
+
+When entering KB mode (*kb-mode), follow these steps:
+
+### 1. Welcome and Guide
+
+Announce entering KB mode with a brief, friendly introduction.
+
+### 2. Present Topic Areas
+
+Offer a concise list of main topic areas the user might want to explore:
+
+**What would you like to know more about?**
+
+1. **Setup & Installation** - Getting started with BMad
+2. **Workflows** - Choosing the right workflow for your project
+3. **Web vs IDE** - When to use each environment
+4. **Agents** - Understanding specialized agents and their roles
+5. **Documents** - PRDs, Architecture, Stories, and more
+6. **Agile Process** - How BMad implements Agile methodologies
+7. **Configuration** - Customizing BMad for your needs
+8. **Best Practices** - Tips for effective BMad usage
+
+Or ask me about anything else related to BMad-Method!
+
+### 3. Respond Contextually
+
+- Wait for user's specific question or topic selection
+- Provide focused, relevant information from the knowledge base
+- Offer to dive deeper or explore related topics
+- Keep responses concise unless user asks for detailed explanations
+
+### 4. Interactive Exploration
+
+- After answering, suggest related topics they might find helpful
+- Maintain conversational flow rather than data dumping
+- Use examples when appropriate
+- Reference specific documentation sections when relevant
+
+### 5. Exit Gracefully
+
+When user is done or wants to exit KB mode:
+
+- Summarize key points discussed if helpful
+- Remind them they can return to KB mode anytime with *kb-mode
+- Suggest next steps based on what was discussed
+
+## Example Interaction
+
+**User**: *kb-mode
+
+**Assistant**: I've entered KB mode and have access to the full BMad knowledge base. I can help you with detailed information about any aspect of BMad-Method.
+
+**What would you like to know more about?**
+
+1. **Setup & Installation** - Getting started with BMad
+2. **Workflows** - Choosing the right workflow for your project
+3. **Web vs IDE** - When to use each environment
+4. **Agents** - Understanding specialized agents and their roles
+5. **Documents** - PRDs, Architecture, Stories, and more
+6. **Agile Process** - How BMad implements Agile methodologies
+7. **Configuration** - Customizing BMad for your needs
+8. **Best Practices** - Tips for effective BMad usage
+
+Or ask me about anything else related to BMad-Method!
+
+**User**: Tell me about workflows
+
+**Assistant**: [Provides focused information about workflows from the KB, then offers to explore specific workflow types or related topics]