appiq-solution 1.0.8 → 1.1.0

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

package/bmad-core/tasks/validate-next-story.md

@@ -0,0 +1,134 @@
+# Validate Next Story Task
+
+## Purpose
+
+To comprehensively validate a story draft before implementation begins, ensuring it is complete, accurate, and provides sufficient context for successful development. This task identifies issues and gaps that need to be addressed, preventing hallucinations and ensuring implementation readiness.
+
+## SEQUENTIAL Task Execution (Do not proceed until current Task is complete)
+
+### 0. Load Core Configuration and Inputs
+
+- Load `.bmad-core/core-config.yaml`
+- If the file does not exist, HALT and inform the user: "core-config.yaml not found. This file is required for story validation."
+- Extract key configurations: `devStoryLocation`, `prd.*`, `architecture.*`
+- Identify and load the following inputs:
+  - **Story file**: The drafted story to validate (provided by user or discovered in `devStoryLocation`)
+  - **Parent epic**: The epic containing this story's requirements
+  - **Architecture documents**: Based on configuration (sharded or monolithic)
+  - **Story template**: `bmad-core/templates/story-tmpl.md` for completeness validation
+
+### 1. Template Completeness Validation
+
+- Load `bmad-core/templates/story-tmpl.md` and extract all section headings from the template
+- **Missing sections check**: Compare story sections against template sections to verify all required sections are present
+- **Placeholder validation**: Ensure no template placeholders remain unfilled (e.g., `{{EpicNum}}`, `{{role}}`, `_TBD_`)
+- **Agent section verification**: Confirm all sections from template exist for future agent use
+- **Structure compliance**: Verify story follows template structure and formatting
+
+### 2. File Structure and Source Tree Validation
+
+- **File paths clarity**: Are new/existing files to be created/modified clearly specified?
+- **Source tree relevance**: Is relevant project structure included in Dev Notes?
+- **Directory structure**: Are new directories/components properly located according to project structure?
+- **File creation sequence**: Do tasks specify where files should be created in logical order?
+- **Path accuracy**: Are file paths consistent with project structure from architecture docs?
+
+### 3. UI/Frontend Completeness Validation (if applicable)
+
+- **Component specifications**: Are UI components sufficiently detailed for implementation?
+- **Styling/design guidance**: Is visual implementation guidance clear?
+- **User interaction flows**: Are UX patterns and behaviors specified?
+- **Responsive/accessibility**: Are these considerations addressed if required?
+- **Integration points**: Are frontend-backend integration points clear?
+
+### 4. Acceptance Criteria Satisfaction Assessment
+
+- **AC coverage**: Will all acceptance criteria be satisfied by the listed tasks?
+- **AC testability**: Are acceptance criteria measurable and verifiable?
+- **Missing scenarios**: Are edge cases or error conditions covered?
+- **Success definition**: Is "done" clearly defined for each AC?
+- **Task-AC mapping**: Are tasks properly linked to specific acceptance criteria?
+
+### 5. Validation and Testing Instructions Review
+
+- **Test approach clarity**: Are testing methods clearly specified?
+- **Test scenarios**: Are key test cases identified?
+- **Validation steps**: Are acceptance criteria validation steps clear?
+- **Testing tools/frameworks**: Are required testing tools specified?
+- **Test data requirements**: Are test data needs identified?
+
+### 6. Security Considerations Assessment (if applicable)
+
+- **Security requirements**: Are security needs identified and addressed?
+- **Authentication/authorization**: Are access controls specified?
+- **Data protection**: Are sensitive data handling requirements clear?
+- **Vulnerability prevention**: Are common security issues addressed?
+- **Compliance requirements**: Are regulatory/compliance needs addressed?
+
+### 7. Tasks/Subtasks Sequence Validation
+
+- **Logical order**: Do tasks follow proper implementation sequence?
+- **Dependencies**: Are task dependencies clear and correct?
+- **Granularity**: Are tasks appropriately sized and actionable?
+- **Completeness**: Do tasks cover all requirements and acceptance criteria?
+- **Blocking issues**: Are there any tasks that would block others?
+
+### 8. Anti-Hallucination Verification
+
+- **Source verification**: Every technical claim must be traceable to source documents
+- **Architecture alignment**: Dev Notes content matches architecture specifications
+- **No invented details**: Flag any technical decisions not supported by source documents
+- **Reference accuracy**: Verify all source references are correct and accessible
+- **Fact checking**: Cross-reference claims against epic and architecture documents
+
+### 9. Dev Agent Implementation Readiness
+
+- **Self-contained context**: Can the story be implemented without reading external docs?
+- **Clear instructions**: Are implementation steps unambiguous?
+- **Complete technical context**: Are all required technical details present in Dev Notes?
+- **Missing information**: Identify any critical information gaps
+- **Actionability**: Are all tasks actionable by a development agent?
+
+### 10. Generate Validation Report
+
+Provide a structured validation report including:
+
+#### Template Compliance Issues
+
+- Missing sections from story template
+- Unfilled placeholders or template variables
+- Structural formatting issues
+
+#### Critical Issues (Must Fix - Story Blocked)
+
+- Missing essential information for implementation
+- Inaccurate or unverifiable technical claims
+- Incomplete acceptance criteria coverage
+- Missing required sections
+
+#### Should-Fix Issues (Important Quality Improvements)
+
+- Unclear implementation guidance
+- Missing security considerations
+- Task sequencing problems
+- Incomplete testing instructions
+
+#### Nice-to-Have Improvements (Optional Enhancements)
+
+- Additional context that would help implementation
+- Clarifications that would improve efficiency
+- Documentation improvements
+
+#### Anti-Hallucination Findings
+
+- Unverifiable technical claims
+- Missing source references
+- Inconsistencies with architecture documents
+- Invented libraries, patterns, or standards
+
+#### Final Assessment
+
+- **GO**: Story is ready for implementation
+- **NO-GO**: Story requires fixes before implementation
+- **Implementation Readiness Score**: 1-10 scale
+- **Confidence Level**: High/Medium/Low for successful implementation