appiq-solution 1.4.2 → 1.4.4

package/bmad-core/tasks/review-story.md

@@ -0,0 +1,145 @@
+# review-story
+
+When a developer agent marks a story as "Ready for Review", perform a comprehensive senior developer code review with the ability to refactor and improve code directly.
+
+## Prerequisites
+
+- Story status must be "Review"
+- Developer has completed all tasks and updated the File List
+- All automated tests are passing
+
+## Review Process
+
+1. **Read the Complete Story**
+   - Review all acceptance criteria
+   - Understand the dev notes and requirements
+   - Note any completion notes from the developer
+
+2. **Verify Implementation Against Dev Notes Guidance**
+   - Review the "Dev Notes" section for specific technical guidance provided to the developer
+   - Verify the developer's implementation follows the architectural patterns specified in Dev Notes
+   - Check that file locations match the project structure guidance in Dev Notes
+   - Confirm any specified libraries, frameworks, or technical approaches were used correctly
+   - Validate that security considerations mentioned in Dev Notes were implemented
+
+3. **Focus on the File List**
+   - Verify all files listed were actually created/modified
+   - Check for any missing files that should have been updated
+   - Ensure file locations align with the project structure guidance from Dev Notes
+
+4. **Senior Developer Code Review**
+   - Review code with the eye of a senior developer
+   - If changes form a cohesive whole, review them together
+   - If changes are independent, review incrementally file by file
+   - Focus on:
+     - Code architecture and design patterns
+     - Refactoring opportunities
+     - Code duplication or inefficiencies
+     - Performance optimizations
+     - Security concerns
+     - Best practices and patterns
+
+5. **Active Refactoring**
+   - As a senior developer, you CAN and SHOULD refactor code where improvements are needed
+   - When refactoring:
+     - Make the changes directly in the files
+     - Explain WHY you're making the change
+     - Describe HOW the change improves the code
+     - Ensure all tests still pass after refactoring
+     - Update the File List if you modify additional files
+
+6. **Standards Compliance Check**
+   - Verify adherence to `docs/coding-standards.md`
+   - Check compliance with `docs/unified-project-structure.md`
+   - Validate testing approach against `docs/testing-strategy.md`
+   - Ensure all guidelines mentioned in the story are followed
+
+7. **Acceptance Criteria Validation**
+   - Verify each AC is fully implemented
+   - Check for any missing functionality
+   - Validate edge cases are handled
+
+8. **Test Coverage Review**
+   - Ensure unit tests cover edge cases
+   - Add missing tests if critical coverage is lacking
+   - Verify integration tests (if required) are comprehensive
+   - Check that test assertions are meaningful
+   - Look for missing test scenarios
+
+9. **Documentation and Comments**
+   - Verify code is self-documenting where possible
+   - Add comments for complex logic if missing
+   - Ensure any API changes are documented
+
+## Update Story File - QA Results Section ONLY
+
+**CRITICAL**: You are ONLY authorized to update the "QA Results" section of the story file. DO NOT modify any other sections.
+
+After review and any refactoring, append your results to the story file in the QA Results section:
+
+```markdown
+## QA Results
+
+### Review Date: [Date]
+### Reviewed By: Quinn (Senior Developer QA)
+
+### Code Quality Assessment
+[Overall assessment of implementation quality]
+
+### Refactoring Performed
+[List any refactoring you performed with explanations]
+- **File**: [filename]
+  - **Change**: [what was changed]
+  - **Why**: [reason for change]
+  - **How**: [how it improves the code]
+
+### Compliance Check
+- Coding Standards: [✓/✗] [notes if any]
+- Project Structure: [✓/✗] [notes if any]
+- Testing Strategy: [✓/✗] [notes if any]
+- All ACs Met: [✓/✗] [notes if any]
+
+### Improvements Checklist
+[Check off items you handled yourself, leave unchecked for dev to address]
+
+- [x] Refactored user service for better error handling (services/user.service.ts)
+- [x] Added missing edge case tests (services/user.service.test.ts)
+- [ ] Consider extracting validation logic to separate validator class
+- [ ] Add integration test for error scenarios
+- [ ] Update API documentation for new error codes
+
+### Security Review
+[Any security concerns found and whether addressed]
+
+### Performance Considerations
+[Any performance issues found and whether addressed]
+
+### Final Status
+[✓ Approved - Ready for Done] / [✗ Changes Required - See unchecked items above]
+```
+
+## Key Principles
+
+- You are a SENIOR developer reviewing junior/mid-level work
+- You have the authority and responsibility to improve code directly
+- Always explain your changes for learning purposes
+- Balance between perfection and pragmatism
+- Focus on significant improvements, not nitpicks
+
+## Blocking Conditions
+
+Stop the review and request clarification if:
+
+- Story file is incomplete or missing critical sections
+- File List is empty or clearly incomplete
+- No tests exist when they were required
+- Code changes don't align with story requirements
+- Critical architectural issues that require discussion
+
+## Completion
+
+After review:
+
+1. If all items are checked and approved: Update story status to "Done"
+2. If unchecked items remain: Keep status as "Review" for dev to address
+3. Always provide constructive feedback and explanations for learning

package/bmad-core/tasks/shard-doc.md

@@ -0,0 +1,187 @@
+# Document Sharding Task
+
+## Purpose
+
+- Split a large document into multiple smaller documents based on level 2 sections
+- Create a folder structure to organize the sharded documents
+- Maintain all content integrity including code blocks, diagrams, and markdown formatting
+
+## Primary Method: Automatic with markdown-tree
+
+[[LLM: First, check if markdownExploder is set to true in {root}/core-config.yaml. If it is, attempt to run the command: `md-tree explode {input file} {output path}`.
+
+If the command succeeds, inform the user that the document has been sharded successfully and STOP - do not proceed further.
+
+If the command fails (especially with an error indicating the command is not found or not available), inform the user: "The markdownExploder setting is enabled but the md-tree command is not available. Please either:
+
+1. Install @kayvan/markdown-tree-parser globally with: `npm install -g @kayvan/markdown-tree-parser`
+2. Or set markdownExploder to false in {root}/core-config.yaml
+
+**IMPORTANT: STOP HERE - do not proceed with manual sharding until one of the above actions is taken.**"
+
+If markdownExploder is set to false, inform the user: "The markdownExploder setting is currently false. For better performance and reliability, you should:
+
+1. Set markdownExploder to true in {root}/core-config.yaml
+2. Install @kayvan/markdown-tree-parser globally with: `npm install -g @kayvan/markdown-tree-parser`
+
+I will now proceed with the manual sharding process."
+
+Then proceed with the manual method below ONLY if markdownExploder is false.]]
+
+### Installation and Usage
+
+1. **Install globally**:
+
+   ```bash
+   npm install -g @kayvan/markdown-tree-parser
+   ```
+
+2. **Use the explode command**:
+
+   ```bash
+   # For PRD
+   md-tree explode docs/prd.md docs/prd
+
+   # For Architecture
+   md-tree explode docs/architecture.md docs/architecture
+
+   # For any document
+   md-tree explode [source-document] [destination-folder]
+   ```
+
+3. **What it does**:
+   - Automatically splits the document by level 2 sections
+   - Creates properly named files
+   - Adjusts heading levels appropriately
+   - Handles all edge cases with code blocks and special markdown
+
+If the user has @kayvan/markdown-tree-parser installed, use it and skip the manual process below.
+
+---
+
+## Manual Method (if @kayvan/markdown-tree-parser is not available or user indicated manual method)
+
+### Task Instructions
+
+1. Identify Document and Target Location
+
+- Determine which document to shard (user-provided path)
+- Create a new folder under `docs/` with the same name as the document (without extension)
+- Example: `docs/prd.md` → create folder `docs/prd/`
+
+2. Parse and Extract Sections
+
+CRITICAL AEGNT SHARDING RULES:
+
+1. Read the entire document content
+2. Identify all level 2 sections (## headings)
+3. For each level 2 section:
+   - Extract the section heading and ALL content until the next level 2 section
+   - Include all subsections, code blocks, diagrams, lists, tables, etc.
+   - Be extremely careful with:
+     - Fenced code blocks (```) - ensure you capture the full block including closing backticks and account for potential misleading level 2's that are actually part of a fenced section example
+     - Mermaid diagrams - preserve the complete diagram syntax
+     - Nested markdown elements
+     - Multi-line content that might contain ## inside code blocks
+
+CRITICAL: Use proper parsing that understands markdown context. A ## inside a code block is NOT a section header.]]
+
+### 3. Create Individual Files
+
+For each extracted section:
+
+1. **Generate filename**: Convert the section heading to lowercase-dash-case
+
+   - Remove special characters
+   - Replace spaces with dashes
+   - Example: "## Tech Stack" → `tech-stack.md`
+
+2. **Adjust heading levels**:
+
+   - The level 2 heading becomes level 1 (# instead of ##) in the sharded new document
+   - All subsection levels decrease by 1:
+
+   ```txt
+     - ### → ##
+     - #### → ###
+     - ##### → ####
+     - etc.
+   ```
+
+3. **Write content**: Save the adjusted content to the new file
+
+### 4. Create Index File
+
+Create an `index.md` file in the sharded folder that:
+
+1. Contains the original level 1 heading and any content before the first level 2 section
+2. Lists all the sharded files with links:
+
+```markdown
+# Original Document Title
+
+[Original introduction content if any]
+
+## Sections
+
+- [Section Name 1](./section-name-1.md)
+- [Section Name 2](./section-name-2.md)
+- [Section Name 3](./section-name-3.md)
+  ...
+```
+
+### 5. Preserve Special Content
+
+1. **Code blocks**: Must capture complete blocks including:
+
+   ```language
+   content
+   ```
+
+2. **Mermaid diagrams**: Preserve complete syntax:
+
+   ```mermaid
+   graph TD
+   ...
+   ```
+
+3. **Tables**: Maintain proper markdown table formatting
+
+4. **Lists**: Preserve indentation and nesting
+
+5. **Inline code**: Preserve backticks
+
+6. **Links and references**: Keep all markdown links intact
+
+7. **Template markup**: If documents contain {{placeholders}} ,preserve exactly
+
+### 6. Validation
+
+After sharding:
+
+1. Verify all sections were extracted
+2. Check that no content was lost
+3. Ensure heading levels were properly adjusted
+4. Confirm all files were created successfully
+
+### 7. Report Results
+
+Provide a summary:
+
+```text
+Document sharded successfully:
+- Source: [original document path]
+- Destination: docs/[folder-name]/
+- Files created: [count]
+- Sections:
+  - section-name-1.md: "Section Title 1"
+  - section-name-2.md: "Section Title 2"
+  ...
+```
+
+## Important Notes
+
+- Never modify the actual content, only adjust heading levels
+- Preserve ALL formatting, including whitespace where significant
+- Handle edge cases like sections with code blocks containing ## symbols
+- Ensure the sharding is reversible (could reconstruct the original from shards)

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

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