@windagency/valora 2.0.1

package/data/commands/test.md

@@ -0,0 +1,263 @@
+---
+name: test
+description: Execute comprehensive test suites (unit, integration, e2e) to validate implementation correctness and quality
+experimental: true
+argument-hint: '[test-scope] [--type=unit|integration|e2e|all] [--coverage-threshold=80]'
+allowed-tools:
+  - codebase_search
+  - read_file
+  - grep
+  - list_dir
+  - glob_file_search
+  - run_terminal_cmd
+  # MCP: Browser automation for E2E tests
+  - mcp_playwright
+  # MCP: Cross-browser testing (optional)
+  - mcp_browserstack
+model: claude-sonnet-4.5
+agent: qa
+prompts:
+  pipeline:
+    - stage: context
+      prompt: test.analyze-test-infrastructure
+      required: true
+      inputs:
+        test_scope: $ARG_1
+      outputs:
+        - test_framework
+        - test_structure
+        - existing_tests
+    - stage: execution
+      prompt: test.execute-tests
+      required: true
+      inputs:
+        test_scope: $ARG_1
+        test_type: $ARG_type
+        coverage_threshold: $ARG_coverage_threshold
+        test_framework: $STAGE_context.test_framework
+        test_structure: $STAGE_context.test_structure
+      outputs:
+        - test_results
+        - coverage_metrics
+        - failed_tests
+    - stage: analysis
+      prompt: test.analyze-results
+      required: true
+      inputs:
+        test_results: $STAGE_execution.test_results
+        coverage_metrics: $STAGE_execution.coverage_metrics
+        coverage_threshold: $ARG_coverage_threshold
+      outputs:
+        - quality_assessment
+        - recommendations
+  merge_strategy: sequential
+  cache_strategy: none
+  retry_policy:
+    max_attempts: 2
+    backoff_ms: 1000
+    retry_on:
+      - timeout
+      - error
+---
+
+# Prompt Orchestration
+
+## Role
+
+Use the [agent] profile
+
+## Goal
+
+Execute comprehensive automated test suites to validate implementation correctness, quality, and adherence to specifications. Provide detailed analysis of test results, coverage metrics, and actionable recommendations for improvement.
+
+## Rules
+
+### Command Orchestration
+
+1. **Execution Flow**
+   - Execute pipeline stages sequentially (cannot parallelize test execution)
+   - Pass outputs from each stage to the next
+   - Continue execution even if tests fail (to gather complete results)
+   - Aggregate all results into final report
+
+2. **Scope Handling**
+   - Apply test scope filter from `$ARG_1` if provided
+   - Support file paths, directories, and patterns
+   - Default to all tests if no scope specified
+
+3. **Threshold Enforcement**
+   - Use `$ARG_coverage_threshold` or default to 80%
+   - Fail if coverage below threshold
+   - Report gaps for files below threshold
+
+4. **Decision Criteria**
+   - **PASS**: All tests pass AND coverage meets threshold
+   - **FAIL**: Any critical tests fail OR coverage significantly below threshold
+   - **WARN**: Minor test failures OR coverage slightly below threshold
+
+### Error Handling
+
+- If test framework not found → provide installation instructions and FAIL
+- If test configuration invalid → diagnose and suggest fixes, then FAIL
+- If tests fail to run → report infrastructure error and FAIL
+- If critical tests fail → classify by severity and FAIL with remediation plan
+- If coverage below threshold → identify gaps and FAIL (or WARN based on margin)
+
+## Context
+
+```plaintext
+$ARGUMENTS
+```
+
+## Process Steps
+
+The test command orchestrates a three-stage pipeline:
+
+1. **Analyze Test Infrastructure** → Detects test framework, configuration, and relevant test files
+2. **Execute Test Suites** → Runs tests by type (unit, integration, e2e) and captures results
+3. **Analyze Results** → Evaluates outcomes, assesses coverage, and provides recommendations
+
+Each stage is implemented as a dedicated prompt (see `prompts/06_test/`).
+
+### Pipeline Flow
+
+```mermaid
+flowchart LR
+    A[test.analyze-test-infrastructure] --> B[test.execute-tests]
+    B --> C[test.analyze-results]
+    C --> D{Pass?}
+    D -->|Yes| E[/review-code]
+    D -->|No| F[Fix & Retest]
+```
+
+### Expected Outputs
+
+**Stage 1 Output**:
+
+- Test framework identification (name, version, config)
+- Test structure mapping (unit, integration, e2e locations)
+- Existing test inventory
+- Environment requirements
+
+**Stage 2 Output**:
+
+- Test execution results (pass/fail/skip counts, duration)
+- Coverage metrics (statements, branches, functions, lines)
+- Failed tests with stack traces
+- Flaky test detection
+
+**Stage 3 Output**:
+
+- Quality assessment (overall status, failure severity)
+- Coverage analysis (gaps, critical uncovered paths)
+- Prioritized recommendations (high/medium/low priority)
+- Next steps (proceed/fix/warn)
+
+## Success Criteria
+
+- ✅ All pipeline stages complete successfully
+- ✅ Test framework detected and tests executed
+- ✅ All critical tests pass (or classified failures provided)
+- ✅ Coverage metrics generated and evaluated against threshold
+- ✅ Quality assessment provided with actionable recommendations
+- ✅ Clear pass/fail decision with justification
+
+## Failure Conditions
+
+- ❌ Test framework not found or not configured
+- ❌ Test execution fails due to infrastructure issues
+- ❌ Any critical tests fail without acceptable justification
+- ❌ Coverage significantly below threshold with high-risk gaps
+- ❌ Unable to generate comprehensive test report
+
+---
+
+**Recommended Next Step**:
+
+- If **PASS** → `/review-code` to verify quality gates
+- If **FAIL** → Address issues and re-run `/test`
+- If **WARN** → Team decision based on risk assessment
+
+## Command Output Summary
+
+Print the following summary at command completion:
+
+**For PASS:**
+
+```markdown
+## ✅ Tests: PASS
+
+**Overall Status**: PASS
+**Coverage**: [XX]% (threshold: 80%)
+
+### Test Results
+
+| Type        | Pass | Fail | Skip |
+| ----------- | ---- | ---- | ---- |
+| Unit        | [N]  | 0    | [N]  |
+| Integration | [N]  | 0    | [N]  |
+| E2E         | [N]  | 0    | [N]  |
+
+### Coverage Summary
+
+- **Statements**: [XX]%
+- **Branches**: [XX]%
+- **Functions**: [XX]%
+- **Lines**: [XX]%
+
+### Next Step
+
+→ `/review-code` to verify code quality
+```
+
+**For FAIL:**
+
+```markdown
+## ❌ Tests: FAIL
+
+**Overall Status**: FAIL
+**Failures**: [N] tests failed
+
+### Test Results
+
+| Type        | Pass | Fail | Skip |
+| ----------- | ---- | ---- | ---- |
+| Unit        | [N]  | [N]  | [N]  |
+| Integration | [N]  | [N]  | [N]  |
+| E2E         | [N]  | [N]  | [N]  |
+
+### Failed Tests
+
+1. **[test-name]**: [failure reason]
+2. **[test-name]**: [failure reason]
+
+### Next Step
+
+→ Fix failing tests and re-run `/test`
+```
+
+**For WARN:**
+
+```markdown
+## ⚠️ Tests: WARN
+
+**Overall Status**: WARN - Proceed with caution
+**Coverage**: [XX]% (below threshold: 80%)
+
+### Test Results
+
+| Type        | Pass | Fail | Skip |
+| ----------- | ---- | ---- | ---- |
+| Unit        | [N]  | 0    | [N]  |
+| Integration | [N]  | 0    | [N]  |
+| E2E         | [N]  | 0    | [N]  |
+
+### Warnings
+
+- Coverage below threshold ([XX]% vs 80%)
+- [Other warnings]
+
+### Next Step
+
+→ Team decision: proceed to `/review-code` or improve coverage
+```

package/data/commands/validate-coverage.md

@@ -0,0 +1,424 @@
+---
+name: validate-coverage
+description: Automated test coverage validation gate with specific thresholds and quality scoring
+experimental: true
+argument-hint: '[--threshold=80] [--strict] [--new-code-only] [--report-format=summary|detailed|json]'
+allowed-tools:
+  - read_file
+  - grep
+  - list_dir
+  - glob_file_search
+  - run_terminal_cmd
+model: claude-haiku-4.5
+agent: qa
+prompts:
+  pipeline:
+    - stage: analyze
+      prompt: test.analyze-test-infrastructure
+      required: true
+      outputs:
+        - test_framework
+        - test_structure
+        - coverage_config
+    - stage: execute
+      prompt: test.execute-coverage-validation
+      required: true
+      inputs:
+        threshold: $ARG_threshold
+        strict: $ARG_strict
+        new_code_only: $ARG_new_code_only
+        test_framework: $STAGE_analyze.test_framework
+      outputs:
+        - coverage_metrics
+        - quality_score
+        - gaps_identified
+        - gate_status
+    - stage: report
+      prompt: test.generate-coverage-report
+      required: true
+      inputs:
+        coverage_metrics: $STAGE_execute.coverage_metrics
+        quality_score: $STAGE_execute.quality_score
+        report_format: $ARG_report_format
+      outputs:
+        - coverage_report
+        - recommendations
+  merge_strategy: sequential
+  cache_strategy: none
+---
+
+# Coverage Validation Command
+
+## Role
+
+Use the [agent] profile (@qa)
+
+## Goal
+
+**Enforce automated test coverage validation gates** to ensure code quality before review or merge. This command addresses low test quality scores by providing specific, measurable coverage requirements with clear pass/fail criteria.
+
+**Primary Objectives**:
+
+1. **Validate coverage thresholds** - Ensure line, branch, and function coverage meet targets
+2. **Calculate quality score** - Generate a composite test quality score (0-100)
+3. **Identify coverage gaps** - Pinpoint files and functions below threshold
+4. **Enforce critical path coverage** - Ensure security and business-critical code is tested
+5. **Provide actionable recommendations** - Guide developers to improve coverage
+
+**This command answers**: "Does our test coverage meet quality gates for merge?"
+
+## Context
+
+### Input Arguments
+
+```plaintext
+$ARGUMENTS
+```
+
+### Configuration Parameters
+
+```structured
+<details>
+<summary>Coverage Validation Configuration</summary>
+
+**--threshold** (default: 80)
+- Minimum overall line coverage percentage required
+- Range: 0-100
+- Recommended: 80 for production code
+
+**--strict** (default: false)
+- Enable strict mode requiring ALL thresholds to pass
+- Tier 1 thresholds become hard requirements
+- New code must have >= 90% coverage
+
+**--new-code-only** (default: false)
+- Only validate coverage for changed/new files
+- Useful for incremental validation in PRs
+- Uses git diff to identify changed files
+
+**--report-format** (default: summary)
+- `summary` - Brief pass/fail with key metrics
+- `detailed` - Full coverage breakdown by file
+- `json` - Machine-readable JSON format
+
+**--fail-on-decrease** (default: true)
+- Fail if coverage decreased from baseline
+- Compares against previous coverage report
+
+</details>
+```
+
+## Rules
+
+### Coverage Thresholds
+
+**Tier 1: Critical Thresholds (Required)**
+
+| Metric                    | Default | Strict Mode |
+| ------------------------- | ------- | ----------- |
+| Overall Line Coverage     | >= 80%  | >= 85%      |
+| Overall Branch Coverage   | >= 70%  | >= 75%      |
+| Overall Function Coverage | >= 85%  | >= 90%      |
+| New Code Coverage         | >= 85%  | >= 95%      |
+
+**Tier 2: File-Level Thresholds**
+
+| File Type              | Line Coverage | Branch Coverage |
+| ---------------------- | ------------- | --------------- |
+| Service/Business Logic | >= 85%        | >= 75%          |
+| Controllers/Routes     | >= 80%        | >= 70%          |
+| Utilities/Helpers      | >= 90%        | >= 80%          |
+| Models/Types           | >= 70%        | >= 60%          |
+
+**Tier 3: Critical Path Coverage**
+
+These MUST have 100% coverage:
+
+- Authentication flows
+- Authorization checks
+- Input validation
+- Error handling for security-sensitive operations
+
+### Quality Score Calculation
+
+```
+Score = (
+  Line Coverage * 0.30 +
+  Branch Coverage * 0.25 +
+  Function Coverage * 0.20 +
+  New Code Coverage * 0.15 +
+  Test Diversity * 0.10
+) * 100
+```
+
+**Grade Thresholds**:
+
+- A (>= 80): PASS
+- B (70-79): PASS with recommendations
+- C (60-69): WARN - requires justification
+- D (50-59): FAIL
+- F (< 50): FAIL - critical
+
+### Decision Criteria
+
+| Tier 1 Pass | Score >= 60 | Coverage Increased | Decision                        |
+| ----------- | ----------- | ------------------ | ------------------------------- |
+| YES         | YES         | YES                | **PASS**                        |
+| YES         | YES         | NO                 | **WARN** - coverage decreased   |
+| YES         | NO          | \*                 | **WARN** - improve test quality |
+| NO          | \*          | \*                 | **FAIL** - must meet thresholds |
+
+## Process Steps
+
+### Step 1: Analyze Test Infrastructure
+
+Detect test framework, configuration, and existing coverage setup.
+
+**Output**: Test framework info, coverage configuration
+
+### Step 2: Run Coverage Analysis
+
+Execute test suite with coverage collection.
+
+```bash
+# Vitest
+pnpm vitest run --coverage
+
+# Jest
+pnpm jest --coverage --coverageReporters=json-summary
+
+# Check coverage report (extract key metrics)
+jq '.total | {lines: .lines.pct, branches: .branches.pct, functions: .functions.pct, statements: .statements.pct}' coverage/coverage-summary.json
+```
+
+### Step 3: Validate Against Thresholds
+
+Compare coverage metrics against configured thresholds.
+
+**Validation checks**:
+
+1. Overall line coverage >= threshold
+2. Overall branch coverage >= (threshold - 10)
+3. Overall function coverage >= (threshold + 5)
+4. New code coverage >= 90% (if --strict)
+5. Critical paths have 100% coverage
+
+### Step 4: Calculate Quality Score
+
+Apply weighted formula to generate composite score.
+
+### Step 5: Identify Coverage Gaps
+
+Find files and functions below threshold.
+
+**Gap categories**:
+
+- CRITICAL: Security-related code uncovered
+- HIGH: Business logic below threshold
+- MEDIUM: API endpoints below threshold
+- LOW: Utilities below threshold
+
+### Step 6: Generate Report
+
+Output coverage report in requested format.
+
+## Output Requirements
+
+### Summary Report
+
+```markdown
+## Coverage Validation: [PASS/WARN/FAIL]
+
+**Quality Score**: [XX]/100 (Grade: [A-F])
+
+### Metrics
+
+| Metric    | Value | Threshold | Status      |
+| --------- | ----- | --------- | ----------- |
+| Lines     | XX%   | 80%       | [PASS/FAIL] |
+| Branches  | XX%   | 70%       | [PASS/FAIL] |
+| Functions | XX%   | 85%       | [PASS/FAIL] |
+| New Code  | XX%   | 90%       | [PASS/FAIL] |
+
+### Gaps Identified
+
+- [N] files below threshold
+- [N] critical paths uncovered
+
+### Recommendations
+
+1. [Specific action to improve coverage]
+2. [Specific action to improve coverage]
+```
+
+### Detailed Report
+
+Includes per-file coverage breakdown with uncovered lines.
+
+### JSON Report
+
+```json
+{
+	"status": "PASS|WARN|FAIL",
+	"qualityScore": 82,
+	"grade": "A",
+	"metrics": {
+		"lines": { "covered": 850, "total": 1000, "pct": 85.0 },
+		"branches": { "covered": 150, "total": 200, "pct": 75.0 },
+		"functions": { "covered": 90, "total": 100, "pct": 90.0 }
+	},
+	"thresholds": {
+		"lines": { "required": 80, "met": true },
+		"branches": { "required": 70, "met": true },
+		"functions": { "required": 85, "met": true }
+	},
+	"gaps": [
+		{
+			"file": "src/services/payment.ts",
+			"coverage": 75,
+			"required": 85,
+			"priority": "HIGH",
+			"uncoveredLines": [23, 45, 67]
+		}
+	],
+	"recommendations": ["Add tests for payment error handling (lines 23, 45)", "Increase branch coverage in auth service"]
+}
+```
+
+## Success Criteria
+
+- ✅ Coverage metrics collected successfully
+- ✅ All Tier 1 thresholds evaluated
+- ✅ Quality score calculated
+- ✅ Coverage gaps identified with priorities
+- ✅ Clear PASS/WARN/FAIL decision
+- ✅ Actionable recommendations provided
+
+## Failure Conditions
+
+- ❌ Test framework not found
+- ❌ Coverage collection fails
+- ❌ Tier 1 thresholds not met (in strict mode)
+- ❌ Critical paths have 0% coverage
+- ❌ Coverage decreased significantly (> 5%)
+
+---
+
+## Command Output Summary
+
+Print the following at command completion:
+
+**For PASS:**
+
+```markdown
+## ✅ Coverage Validation: PASS
+
+**Quality Score**: 82/100 (Grade: A)
+
+### Metrics
+
+| Metric    | Value | Threshold | Status |
+| --------- | ----- | --------- | ------ |
+| Lines     | 85%   | 80%       | ✅     |
+| Branches  | 75%   | 70%       | ✅     |
+| Functions | 90%   | 85%       | ✅     |
+
+### Next Step
+
+→ `/review-code` to proceed with code review
+```
+
+**For WARN:**
+
+```markdown
+## ⚠️ Coverage Validation: WARN
+
+**Quality Score**: 68/100 (Grade: C)
+
+### Metrics
+
+| Metric    | Value | Threshold | Status |
+| --------- | ----- | --------- | ------ |
+| Lines     | 78%   | 80%       | ⚠️     |
+| Branches  | 65%   | 70%       | ⚠️     |
+| Functions | 85%   | 85%       | ✅     |
+
+### Gaps (2 files)
+
+- `src/services/auth.ts`: 72% (need 85%)
+- `src/controllers/user.ts`: 68% (need 80%)
+
+### Next Step
+
+→ Improve coverage or proceed with justification
+```
+
+**For FAIL:**
+
+```markdown
+## ❌ Coverage Validation: FAIL
+
+**Quality Score**: 45/100 (Grade: F)
+
+### Metrics
+
+| Metric    | Value | Threshold | Status |
+| --------- | ----- | --------- | ------ |
+| Lines     | 55%   | 80%       | ❌     |
+| Branches  | 40%   | 70%       | ❌     |
+| Functions | 60%   | 85%       | ❌     |
+
+### Critical Gaps
+
+- `src/auth/login.ts`: 0% coverage (CRITICAL)
+- `src/services/payment.ts`: 30% coverage (HIGH)
+
+### Required Actions
+
+1. Add unit tests for authentication service
+2. Add integration tests for payment flow
+3. Increase overall coverage by 25%
+
+### Next Step
+
+→ Must improve coverage before proceeding
+```
+
+---
+
+## Integration with Workflow
+
+This command fits into the development workflow:
+
+```
+/implement
+    |
+    v
+/validate-coverage  <-- New validation gate
+    |
+    v (if PASS)
+/assert
+    |
+    v
+/review-code
+```
+
+**Recommended workflow**:
+
+```bash
+# After implementation
+valora implement
+
+# Validate coverage (quick)
+valora validate-coverage --threshold=80
+
+# If PASS, continue to review
+valora validate-parallel --quick
+valora commit
+```
+
+**For strict validation (CI/CD)**:
+
+```bash
+valora validate-coverage --strict --fail-on-decrease --report-format=json
+```