agentvibes 2.13.7 → 2.13.8

package/.claude/commands/BMad/tasks/shard-doc.md

@@ -1,191 +0,0 @@
-# /shard-doc Task
-
-When this command is used, execute the following task:
-
-<!-- Powered by BMAD™ Core -->
-
-# 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 .bmad-core/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 .bmad-core/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 .bmad-core/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/.claude/commands/BMad/tasks/test-design.md

@@ -1,180 +0,0 @@
-# /test-design Task
-
-When this command is used, execute the following task:
-
-<!-- Powered by BMAD™ Core -->
-
-# test-design
-
-Create comprehensive test scenarios with appropriate test level recommendations for story implementation.
-
-## Inputs
-
-```yaml
-required:
-  - story_id: '{epic}.{story}' # e.g., "1.3"
-  - story_path: '{devStoryLocation}/{epic}.{story}.*.md' # Path from core-config.yaml
-  - story_title: '{title}' # If missing, derive from story file H1
-  - story_slug: '{slug}' # If missing, derive from title (lowercase, hyphenated)
-```
-
-## Purpose
-
-Design a complete test strategy that identifies what to test, at which level (unit/integration/e2e), and why. This ensures efficient test coverage without redundancy while maintaining appropriate test boundaries.
-
-## Dependencies
-
-```yaml
-data:
-  - test-levels-framework.md # Unit/Integration/E2E decision criteria
-  - test-priorities-matrix.md # P0/P1/P2/P3 classification system
-```
-
-## Process
-
-### 1. Analyze Story Requirements
-
-Break down each acceptance criterion into testable scenarios. For each AC:
-
-- Identify the core functionality to test
-- Determine data variations needed
-- Consider error conditions
-- Note edge cases
-
-### 2. Apply Test Level Framework
-
-**Reference:** Load `test-levels-framework.md` for detailed criteria
-
-Quick rules:
-
-- **Unit**: Pure logic, algorithms, calculations
-- **Integration**: Component interactions, DB operations
-- **E2E**: Critical user journeys, compliance
-
-### 3. Assign Priorities
-
-**Reference:** Load `test-priorities-matrix.md` for classification
-
-Quick priority assignment:
-
-- **P0**: Revenue-critical, security, compliance
-- **P1**: Core user journeys, frequently used
-- **P2**: Secondary features, admin functions
-- **P3**: Nice-to-have, rarely used
-
-### 4. Design Test Scenarios
-
-For each identified test need, create:
-
-```yaml
-test_scenario:
-  id: '{epic}.{story}-{LEVEL}-{SEQ}'
-  requirement: 'AC reference'
-  priority: P0|P1|P2|P3
-  level: unit|integration|e2e
-  description: 'What is being tested'
-  justification: 'Why this level was chosen'
-  mitigates_risks: ['RISK-001'] # If risk profile exists
-```
-
-### 5. Validate Coverage
-
-Ensure:
-
-- Every AC has at least one test
-- No duplicate coverage across levels
-- Critical paths have multiple levels
-- Risk mitigations are addressed
-
-## Outputs
-
-### Output 1: Test Design Document
-
-**Save to:** `qa.qaLocation/assessments/{epic}.{story}-test-design-{YYYYMMDD}.md`
-
-```markdown
-# Test Design: Story {epic}.{story}
-
-Date: {date}
-Designer: Quinn (Test Architect)
-
-## Test Strategy Overview
-
-- Total test scenarios: X
-- Unit tests: Y (A%)
-- Integration tests: Z (B%)
-- E2E tests: W (C%)
-- Priority distribution: P0: X, P1: Y, P2: Z
-
-## Test Scenarios by Acceptance Criteria
-
-### AC1: {description}
-
-#### Scenarios
-
-| ID           | Level       | Priority | Test                      | Justification            |
-| ------------ | ----------- | -------- | ------------------------- | ------------------------ |
-| 1.3-UNIT-001 | Unit        | P0       | Validate input format     | Pure validation logic    |
-| 1.3-INT-001  | Integration | P0       | Service processes request | Multi-component flow     |
-| 1.3-E2E-001  | E2E         | P1       | User completes journey    | Critical path validation |
-
-[Continue for all ACs...]
-
-## Risk Coverage
-
-[Map test scenarios to identified risks if risk profile exists]
-
-## Recommended Execution Order
-
-1. P0 Unit tests (fail fast)
-2. P0 Integration tests
-3. P0 E2E tests
-4. P1 tests in order
-5. P2+ as time permits
-```
-
-### Output 2: Gate YAML Block
-
-Generate for inclusion in quality gate:
-
-```yaml
-test_design:
-  scenarios_total: X
-  by_level:
-    unit: Y
-    integration: Z
-    e2e: W
-  by_priority:
-    p0: A
-    p1: B
-    p2: C
-  coverage_gaps: [] # List any ACs without tests
-```
-
-### Output 3: Trace References
-
-Print for use by trace-requirements task:
-
-```text
-Test design matrix: qa.qaLocation/assessments/{epic}.{story}-test-design-{YYYYMMDD}.md
-P0 tests identified: {count}
-```
-
-## Quality Checklist
-
-Before finalizing, verify:
-
-- [ ] Every AC has test coverage
-- [ ] Test levels are appropriate (not over-testing)
-- [ ] No duplicate coverage across levels
-- [ ] Priorities align with business risk
-- [ ] Test IDs follow naming convention
-- [ ] Scenarios are atomic and independent
-
-## Key Principles
-
-- **Shift left**: Prefer unit over integration, integration over E2E
-- **Risk-based**: Focus on what could go wrong
-- **Efficient coverage**: Test once at the right level
-- **Maintainability**: Consider long-term test maintenance
-- **Fast feedback**: Quick tests run first

package/.claude/commands/BMad/tasks/trace-requirements.md

@@ -1,270 +0,0 @@
-# /trace-requirements Task
-
-When this command is used, execute the following task:
-
-<!-- Powered by BMAD™ Core -->
-
-# trace-requirements
-
-Map story requirements to test cases using Given-When-Then patterns for comprehensive traceability.
-
-## Purpose
-
-Create a requirements traceability matrix that ensures every acceptance criterion has corresponding test coverage. This task helps identify gaps in testing and ensures all requirements are validated.
-
-**IMPORTANT**: Given-When-Then is used here for documenting the mapping between requirements and tests, NOT for writing the actual test code. Tests should follow your project's testing standards (no BDD syntax in test code).
-
-## Prerequisites
-
-- Story file with clear acceptance criteria
-- Access to test files or test specifications
-- Understanding of the implementation
-
-## Traceability Process
-
-### 1. Extract Requirements
-
-Identify all testable requirements from:
-
-- Acceptance Criteria (primary source)
-- User story statement
-- Tasks/subtasks with specific behaviors
-- Non-functional requirements mentioned
-- Edge cases documented
-
-### 2. Map to Test Cases
-
-For each requirement, document which tests validate it. Use Given-When-Then to describe what the test validates (not how it's written):
-
-```yaml
-requirement: 'AC1: User can login with valid credentials'
-test_mappings:
-  - test_file: 'auth/login.test.ts'
-    test_case: 'should successfully login with valid email and password'
-    # Given-When-Then describes WHAT the test validates, not HOW it's coded
-    given: 'A registered user with valid credentials'
-    when: 'They submit the login form'
-    then: 'They are redirected to dashboard and session is created'
-    coverage: full
-
-  - test_file: 'e2e/auth-flow.test.ts'
-    test_case: 'complete login flow'
-    given: 'User on login page'
-    when: 'Entering valid credentials and submitting'
-    then: 'Dashboard loads with user data'
-    coverage: integration
-```
-
-### 3. Coverage Analysis
-
-Evaluate coverage for each requirement:
-
-**Coverage Levels:**
-
-- `full`: Requirement completely tested
-- `partial`: Some aspects tested, gaps exist
-- `none`: No test coverage found
-- `integration`: Covered in integration/e2e tests only
-- `unit`: Covered in unit tests only
-
-### 4. Gap Identification
-
-Document any gaps found:
-
-```yaml
-coverage_gaps:
-  - requirement: 'AC3: Password reset email sent within 60 seconds'
-    gap: 'No test for email delivery timing'
-    severity: medium
-    suggested_test:
-      type: integration
-      description: 'Test email service SLA compliance'
-
-  - requirement: 'AC5: Support 1000 concurrent users'
-    gap: 'No load testing implemented'
-    severity: high
-    suggested_test:
-      type: performance
-      description: 'Load test with 1000 concurrent connections'
-```
-
-## Outputs
-
-### Output 1: Gate YAML Block
-
-**Generate for pasting into gate file under `trace`:**
-
-```yaml
-trace:
-  totals:
-    requirements: X
-    full: Y
-    partial: Z
-    none: W
-  planning_ref: 'qa.qaLocation/assessments/{epic}.{story}-test-design-{YYYYMMDD}.md'
-  uncovered:
-    - ac: 'AC3'
-      reason: 'No test found for password reset timing'
-  notes: 'See qa.qaLocation/assessments/{epic}.{story}-trace-{YYYYMMDD}.md'
-```
-
-### Output 2: Traceability Report
-
-**Save to:** `qa.qaLocation/assessments/{epic}.{story}-trace-{YYYYMMDD}.md`
-
-Create a traceability report with:
-
-```markdown
-# Requirements Traceability Matrix
-
-## Story: {epic}.{story} - {title}
-
-### Coverage Summary
-
-- Total Requirements: X
-- Fully Covered: Y (Z%)
-- Partially Covered: A (B%)
-- Not Covered: C (D%)
-
-### Requirement Mappings
-
-#### AC1: {Acceptance Criterion 1}
-
-**Coverage: FULL**
-
-Given-When-Then Mappings:
-
-- **Unit Test**: `auth.service.test.ts::validateCredentials`
-  - Given: Valid user credentials
-  - When: Validation method called
-  - Then: Returns true with user object
-
-- **Integration Test**: `auth.integration.test.ts::loginFlow`
-  - Given: User with valid account
-  - When: Login API called
-  - Then: JWT token returned and session created
-
-#### AC2: {Acceptance Criterion 2}
-
-**Coverage: PARTIAL**
-
-[Continue for all ACs...]
-
-### Critical Gaps
-
-1. **Performance Requirements**
-   - Gap: No load testing for concurrent users
-   - Risk: High - Could fail under production load
-   - Action: Implement load tests using k6 or similar
-
-2. **Security Requirements**
-   - Gap: Rate limiting not tested
-   - Risk: Medium - Potential DoS vulnerability
-   - Action: Add rate limit tests to integration suite
-
-### Test Design Recommendations
-
-Based on gaps identified, recommend:
-
-1. Additional test scenarios needed
-2. Test types to implement (unit/integration/e2e/performance)
-3. Test data requirements
-4. Mock/stub strategies
-
-### Risk Assessment
-
-- **High Risk**: Requirements with no coverage
-- **Medium Risk**: Requirements with only partial coverage
-- **Low Risk**: Requirements with full unit + integration coverage
-```
-
-## Traceability Best Practices
-
-### Given-When-Then for Mapping (Not Test Code)
-
-Use Given-When-Then to document what each test validates:
-
-**Given**: The initial context the test sets up
-
-- What state/data the test prepares
-- User context being simulated
-- System preconditions
-
-**When**: The action the test performs
-
-- What the test executes
-- API calls or user actions tested
-- Events triggered
-
-**Then**: What the test asserts
-
-- Expected outcomes verified
-- State changes checked
-- Values validated
-
-**Note**: This is for documentation only. Actual test code follows your project's standards (e.g., describe/it blocks, no BDD syntax).
-
-### Coverage Priority
-
-Prioritize coverage based on:
-
-1. Critical business flows
-2. Security-related requirements
-3. Data integrity requirements
-4. User-facing features
-5. Performance SLAs
-
-### Test Granularity
-
-Map at appropriate levels:
-
-- Unit tests for business logic
-- Integration tests for component interaction
-- E2E tests for user journeys
-- Performance tests for NFRs
-
-## Quality Indicators
-
-Good traceability shows:
-
-- Every AC has at least one test
-- Critical paths have multiple test levels
-- Edge cases are explicitly covered
-- NFRs have appropriate test types
-- Clear Given-When-Then for each test
-
-## Red Flags
-
-Watch for:
-
-- ACs with no test coverage
-- Tests that don't map to requirements
-- Vague test descriptions
-- Missing edge case coverage
-- NFRs without specific tests
-
-## Integration with Gates
-
-This traceability feeds into quality gates:
-
-- Critical gaps → FAIL
-- Minor gaps → CONCERNS
-- Missing P0 tests from test-design → CONCERNS
-
-### Output 3: Story Hook Line
-
-**Print this line for review task to quote:**
-
-```text
-Trace matrix: qa.qaLocation/assessments/{epic}.{story}-trace-{YYYYMMDD}.md
-```
-
-- Full coverage → PASS contribution
-
-## Key Principles
-
-- Every requirement must be testable
-- Use Given-When-Then for clarity
-- Identify both presence and absence
-- Prioritize based on risk
-- Make recommendations actionable