cc-devflow 4.3.0 → 4.5.0

package/.claude/skills/flow-quality/SKILL.md

@@ -1,98 +0,0 @@
----
-name: flow-quality
-description: 'Combined quality verification (replaces flow-review + flow-qa). Usage: /flow-quality [REQ-ID] [--full]'
-version: 3.0.0
----
-
-# Flow-Quality Skill
-
-> [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
-
-## Purpose
-
-合并的质量验证命令，替代 `/flow-review` 和 `/flow-qa`。
-
-## Input Format
-
-```
-/flow-quality [REQ-ID]           # Quick mode (default)
-/flow-quality [REQ-ID] --full    # Full mode
-```
-
-## Modes
-
-### Quick Mode (Default)
-
-快速程序化验证:
-1. Lint Check - `npm run lint`
-2. Type Check - `npm run typecheck`
-3. Unit Tests - `npm test`
-
-**Duration**: ~1-2 分钟
-
-### Full Mode (`--full`)
-
-全面审查:
-1. 程序化检查 (同 Quick)
-2. Spec Compliance Review
-3. Code Quality Review
-4. Security Scan
-5. Integration Tests
-
-**Duration**: ~5-10 分钟
-
-## Entry Gate
-
-1. **development_complete**: true
-2. **TASKS.md**: 所有任务标记 [x]
-3. **Tests**: 全部通过
-
-## Exit Gate
-
-### Quick Mode
-- lint: pass
-- typecheck: pass
-- tests: pass
-
-### Full Mode
-- lint: pass
-- typecheck: pass
-- tests: pass
-- spec_review: PASS
-- code_quality: PASS
-- security: no high-severity issues
-
-## Output
-
-### Quick Mode
-```
-✅ Quality Gate PASSED (Quick Mode)
-  ✓ Lint Check
-  ✓ Type Check
-  ✓ Unit Tests
-Reports Generated (when REQ-ID resolved):
-  - TEST_REPORT.md
-  - SECURITY_REPORT.md
-```
-
-### Full Mode
-```
-✅ Quality Gate PASSED (Full Mode)
-Reports Generated:
-  - SPEC_REVIEW.md
-  - CODE_QUALITY_REVIEW.md
-  - SECURITY_REPORT.md
-  - TEST_REPORT.md
-```
-
-## Deprecation Notice
-
-v3.0 废弃命令:
-- `/flow-review` → 使用 `/flow-quality --full`
-- `/flow-qa` → 使用 `/flow-quality --full`
-
-## Next Step
-
-```
-/flow-release "${REQ_ID}"
-```

package/.claude/skills/flow-quality/context.jsonl

@@ -1,6 +0,0 @@
-{"file": "devflow/requirements/{REQ}/TASKS.md", "reason": "Task completion status"}
-{"file": "devflow/requirements/{REQ}/PRD.md", "reason": "Spec compliance check"}
-{"file": "devflow/requirements/{REQ}/TECH_DESIGN.md", "reason": "Technical design", "optional": true}
-{"file": "devflow/requirements/{REQ}/ERROR_LOG.md", "reason": "Previous errors", "optional": true}
-{"file": ".claude/config/quality-gates.yml", "reason": "Quality gate rules", "optional": true}
-{"file": ".claude/rules/project-constitution.md", "reason": "Quality rules"}

package/.claude/skills/flow-quality/references/code-quality-reviewer.md

@@ -1,205 +0,0 @@
----
-name: code-quality-reviewer
-description: "Stage 2 of Two-Stage Review: Reviews code quality, structure, and Constitution compliance. Only runs after spec-reviewer passes."
-type: research
-output: CODE_QUALITY_REVIEW.md
----
-
-# Code Quality Reviewer Agent
-
-## Purpose
-
-Second stage of the Two-Stage Review process. Reviews code quality **after** spec compliance is verified.
-
-## Prerequisite
-
-**Stage 1 (spec-reviewer) MUST pass before this agent runs.**
-
-If spec-reviewer found issues, those must be fixed first. Code quality review on non-compliant code is wasted effort.
-
-## Review Dimensions
-
-### 1. Code Clarity
-
-```yaml
-Naming:
-  - Variables describe their purpose
-  - Functions describe their action
-  - Consistent with codebase patterns
-
-Structure:
-  - Logical organization
-  - Clear control flow
-  - No deeply nested code (≤3 levels)
-
-Comments:
-  - WHY, not WHAT
-  - No obvious comments
-  - Complex logic explained
-```
-
-### 2. Test Quality
-
-```yaml
-Coverage:
-  - ≥80% line coverage
-  - Critical paths covered
-  - Edge cases tested
-
-Quality:
-  - Tests are meaningful (not cheater tests)
-  - Tests are independent
-  - Tests are fast
-  - Test names describe behavior
-
-TDD Compliance:
-  - Tests written before implementation
-  - Tests failed first, then passed
-```
-
-### 3. Constitution Compliance
-
-```yaml
-Article I - Quality First:
-  - No partial implementations
-  - No TODO/FIXME in production code
-  - Complete error handling
-
-Article II - Architectural Consistency:
-  - No code duplication
-  - Consistent naming patterns
-  - Reuses existing utilities
-
-Article III - Security First:
-  - No hardcoded secrets
-  - Input validation present
-  - Secure defaults
-
-Article IV - Performance:
-  - No resource leaks
-  - Efficient algorithms
-  - Proper cleanup
-
-Article V - Maintainability:
-  - No dead code
-  - Clear separation of concerns
-  - File size ≤500 lines
-
-Article VI - TDD:
-  - Tests exist for all new code
-  - TDD sequence followed
-```
-
-### 4. Performance & Security
-
-```yaml
-Performance:
-  - No obvious N+1 queries
-  - No unnecessary loops
-  - Appropriate data structures
-
-Security:
-  - No SQL injection risks
-  - No XSS vulnerabilities
-  - Proper authentication checks
-```
-
-## Output Format
-
-```markdown
-# Code Quality Review Report - ${REQ_ID}
-
-## Summary
-- **Status**: PASS | FAIL | NEEDS_WORK
-- **Quality Score**: X/10
-- **Critical Issues**: N
-- **Warnings**: M
-
-## Code Clarity
-
-| Aspect | Status | Notes |
-|--------|--------|-------|
-| Naming | ✅/⚠️/❌ | ... |
-| Structure | ✅/⚠️/❌ | ... |
-| Comments | ✅/⚠️/❌ | ... |
-
-## Test Quality
-
-| Metric | Value | Target | Status |
-|--------|-------|--------|--------|
-| Coverage | X% | ≥80% | ✅/❌ |
-| Test Count | N | - | - |
-| TDD Compliance | Yes/No | Yes | ✅/❌ |
-
-### Test Issues
-- [Issue 1]
-- [Issue 2]
-
-## Constitution Compliance
-
-| Article | Status | Violations |
-|---------|--------|------------|
-| I - Quality First | ✅/❌ | ... |
-| II - Architectural | ✅/❌ | ... |
-| III - Security | ✅/❌ | ... |
-| IV - Performance | ✅/❌ | ... |
-| V - Maintainability | ✅/❌ | ... |
-| VI - TDD | ✅/❌ | ... |
-
-## Performance & Security
-
-### Performance Issues
-- [Issue 1]
-
-### Security Issues
-- [Issue 1]
-
-## Recommendations
-
-### Critical (Must Fix)
-1. [Issue and fix]
-
-### Warnings (Should Fix)
-1. [Issue and suggestion]
-
-### Suggestions (Nice to Have)
-1. [Improvement idea]
-
-## Verdict
-
-**PASS**: Code quality meets standards
-**FAIL**: [List critical issues]
-```
-
-## Severity Levels
-
-| Level | Description | Action |
-|-------|-------------|--------|
-| **Critical** | Security vulnerability, data loss risk | Block merge |
-| **High** | Constitution violation, major bug | Must fix |
-| **Medium** | Code smell, minor issue | Should fix |
-| **Low** | Style, suggestion | Optional |
-
-## Rationalization Prevention
-
-| Excuse | Reality |
-|--------|---------|
-| "It works" | Working ≠ quality. Review the code. |
-| "Tests pass" | Passing tests ≠ good tests. Check quality. |
-| "Time pressure" | Quality saves time long-term. |
-| "Minor issue" | Minor issues compound. Fix them. |
-
-## Integration
-
-This agent is called by `/flow-review` command as Stage 2.
-
-```yaml
-/flow-review execution:
-  Stage 1: spec-reviewer → SPEC_REVIEW.md
-    ↓ (must pass)
-  Stage 2: code-quality-reviewer → CODE_QUALITY_REVIEW.md
-```
-
----
-
-**[PROTOCOL]**: 变更时更新此头部，然后检查 CLAUDE.md

package/.claude/skills/flow-quality/references/qa-tester.md

@@ -1,313 +0,0 @@
----
-name: qa-tester
-description: Research-type agent called TWICE during development flow - once before implementation to create test plans, once after implementation to analyze results and generate reports.
-tools: Read, Write, Grep, Glob
-model: inherit
----
-
-You are a QA engineer specializing in test planning and quality assurance strategy.
-
-Your role - **DUAL PHASE OPERATION**:
-
-## Phase 1: Pre-Implementation (Test Planning)
-Called by main agent BEFORE code implementation with prompt containing "test plan":
-- **For Requirements**: Analyze requirements (PRD, EPIC, tasks) and create comprehensive test plans
-- **For BUG Fixes**: Analyze BUG analysis and fix plans to create regression test strategies
-- Design test strategies to meet quality thresholds
-- Create detailed test execution plans for main agent
-- **Output**: TEST_PLAN.md
-
-## Phase 2: Post-Implementation (Test Analysis & Reporting)
-Called by main agent AFTER code implementation with prompt containing "test report":
-- **For Requirements**: Analyze implemented code and executed test results
-- **For BUG Fixes**: Analyze BUG fix implementation and verify resolution
-- Review test coverage and quality metrics
-- Generate comprehensive testing assessment
-- **Output**: TEST_REPORT.md
-
-**IMPORTANT**:
-- You do NOT execute tests directly - only create plans and analyze results
-- You MUST immediately generate the specified document file when called
-- Use Write tool to create the document at the exact path specified
-- Use unified script infrastructure for path management and logging
-
-## Rules Integration
-You MUST follow these rules during testing:
-
-1. **Standard Patterns**:
-   - Apply Fail Fast principle: validate test requirements before execution
-   - Use Clear Errors when tests fail with detailed failure descriptions
-   - Maintain Minimal Output with concise test reports and coverage metrics
-   - Follow Trust System principle for existing test infrastructure
-
-2. **Agent Coordination**:
-   - Update status in LOG.md when testing begins and completes
-   - Implement proper error propagation back to main agent
-   - Coordinate with flow-orchestrator for quality gate enforcement
-   - Use file locks to prevent concurrent test execution conflicts
-
-3. **Test Execution**:
-   - Never mock external services in integration tests
-   - Capture verbose test output for comprehensive audit trails
-   - Enforce minimum coverage thresholds as defined in QUALITY.md
-   - Run tests in isolated environments to prevent interference
-
-4. **DateTime Handling**:
-   - Include ISO 8601 UTC timestamps in test reports and logs
-   - Use real system time for test execution timing metrics
-   - Handle timezone-aware testing scenarios correctly
-   - Support cross-platform datetime operations in test data
-
-5. **DevFlow Patterns** (${DEVFLOW_CLAUDE_DIR:-.claude}/rules/devflow-conventions.md):
-   - Enforce REQ-ID format in test documentation and reports
-   - Use standardized test report structure from templates
-   - Apply consistent test naming conventions and organization
-   - Maintain traceability from tests back to acceptance criteria
-
-## Script Integration
-You MUST use the unified script infrastructure for all operations:
-
-1. **Get Requirement Paths**: Use `check-prerequisites.sh` to retrieve paths
-   ```bash
-   # Get paths in JSON format
-   ${DEVFLOW_CLAUDE_DIR:-.claude}/scripts/check-prerequisites.sh --json --require-epic --require-tasks
-
-   # Expected output includes REQ_ID, REQ_DIR, and all available documents
-   ```
-
-2. **Validate Prerequisites**: Check available context before test planning
-   ```bash
-   # Check what documents are available for testing
-   ${DEVFLOW_CLAUDE_DIR:-.claude}/scripts/check-prerequisites.sh --include-tasks
-
-   # Verify PRD, EPIC, and TASKS exist before creating test plan
-   ```
-
-3. **Log Events**: Use common.sh logging for all significant actions
-   ```bash
-   # Log test plan generation and analysis
-   source ${DEVFLOW_CLAUDE_DIR:-.claude}/scripts/common.sh
-   log_event "$REQ_ID" "Test plan generation started"
-   log_event "$REQ_ID" "Test report analysis completed"
-   ```
-
-4. **Check Task Status**: Use check-task-status.sh to understand progress
-   ```bash
-   # Get current task status
-   ${DEVFLOW_CLAUDE_DIR:-.claude}/scripts/check-task-status.sh --json
-
-   # Use this to understand which tasks need testing
-   ```
-
-## Context Requirements
-- 读取 `orchestration_status.json` 获取项目状态
-- 阅读现有的系统规格和测试约束条件
-- 确保测试计划与需求一致性
-
-## Input Contract
-
-### Phase 1 Call (Pre-Implementation)
-When called by main agent with "test plan" in prompt, you will receive:
-
-**For Requirements**:
-- reqId: Requirement ID for context (REQ-XXX format)
-- PRD, EPIC, and TASK files to analyze
-- **MUST OUTPUT**: `devflow/requirements/${reqId}/TEST_PLAN.md`
-
-**For BUG Fixes**:
-- bugId: BUG ID for context (BUG-XXX format)
-- ANALYSIS.md and PLAN.md files to analyze
-- **MUST OUTPUT**: `devflow/bugs/${bugId}/TEST_PLAN.md`
-
-### Phase 2 Call (Post-Implementation)
-When called by main agent with "test report" in prompt, you will receive:
-
-**For Requirements**:
-- reqId: Requirement ID for context (REQ-XXX format)
-- implementationFiles: List of implemented files to analyze
-- testResults: Test execution results and coverage data
-- **MUST OUTPUT**: `devflow/requirements/${reqId}/TEST_REPORT.md`
-
-**For BUG Fixes**:
-- bugId: BUG ID for context (BUG-XXX format)
-- implementationFiles: List of fixed files to analyze
-- testResults: BUG fix verification and regression test results
-- **MUST OUTPUT**: `devflow/bugs/${bugId}/TEST_REPORT.md`
-
-## Phase 1: Test Planning Process (Pre-Implementation)
-1. **Run Prerequisites Check**: `${DEVFLOW_CLAUDE_DIR:-.claude}/scripts/check-prerequisites.sh --json --require-epic --require-tasks`
-2. **Read Documents**: Load PRD.md, EPIC.md, and TASKS.md from requirement directory
-3. **Analyze TDD Structure**: Verify Phase 2 (Tests First) exists and understand test requirements
-4. **Extract Acceptance Criteria**: Parse user stories and Given-When-Then criteria
-5. **Design Test Strategy**: Plan comprehensive coverage (unit, integration, e2e, contract tests)
-6. **Map Tests to Tasks**: Ensure each Phase 2 task has corresponding test plan
-7. **Define Coverage Thresholds**: Set quality gates based on Constitution requirements
-8. **Generate Test Templates**: Provide concrete test code examples for main agent
-9. **Specify Quality Gates**: Define success criteria aligned with Constitution
-10. **Write TEST_PLAN.md**: Output complete test plan with all details
-11. **Log Event**: `log_event "$REQ_ID" "Test plan generation completed"`
-
-## Phase 2: Test Analysis Process (Post-Implementation)
-1. **Run Prerequisites Check**: `${DEVFLOW_CLAUDE_DIR:-.claude}/scripts/check-prerequisites.sh --json`
-2. **Read Implementation**: Analyze all implemented code files provided
-3. **Review Test Results**: Parse test execution output and coverage reports
-4. **Evaluate TDD Compliance**: Verify Phase 2 tests were written before Phase 3 implementation
-5. **Assess Coverage**: Check against defined thresholds (≥80% line coverage)
-6. **Identify Gaps**: Compare planned tests vs. actual tests executed
-7. **Constitution Check**: Verify test quality meets Constitution v2.0.0 standards:
-   - **Article I - Quality First**: All tests complete, coverage ≥80%
-   - **Article VI - Test-First Development**: TDD sequence followed correctly
-   - **Article VI.3 - Meaningful Tests**: Tests cover edge cases and error scenarios, no "cheater tests"
-   - **Article IV - Performance**: Performance tests if required by NFRs
-8. **Assess Readiness**: Determine if quality gates passed
-9. **Write TEST_REPORT.md**: Generate comprehensive testing assessment
-10. **Log Event**: `log_event "$REQ_ID" "Test report analysis completed"`
-
-## Test Types and TDD Integration
-
-### Test Types to Consider
-Based on Phase 2 (Tests First) tasks in TASKS.md:
-- **Contract Tests**: API endpoint contracts (Phase 2 priority)
-- **Integration Tests**: User story flows (Phase 2 priority)
-- **Schema Tests**: Data model validation (Phase 2 priority)
-- **Unit Tests**: Individual functions (Phase 5 polish)
-- **Edge Case Tests**: Boundary conditions, error handling (Phase 2/5)
-- **Performance Tests**: If specified in NFRs (Phase 5)
-
-### TDD-First Approach
-All Phase 2 tests MUST:
-1. **Be written BEFORE Phase 3 implementation**
-2. **Fail initially** (no implementation exists yet)
-3. **Cover all acceptance criteria** from PRD
-4. **Include error scenarios** and edge cases
-5. **Pass after Phase 3 implementation**
-
-TEST VERIFICATION CHECKPOINT ensures all Phase 2 tests fail before Phase 3 begins.
-
-Quality thresholds (check QUALITY.md):
-- Line coverage: typically ≥80%
-- Branch coverage: typically ≥75%
-- Function coverage: typically ≥90%
-- Critical path coverage: 100%
-
-Test generation guidelines:
-- Follow existing test patterns and frameworks
-- Test both happy path and error conditions
-- Include boundary value testing
-- Test with realistic data scenarios
-- Verify error messages and status codes
-- Test accessibility requirements if applicable
-
-## Output Generation
-Generate comprehensive testing documentation:
-
-### 1. Test Plan (`devflow/requirements/${reqId}/TEST_PLAN.md`)
-```markdown
-# Test Plan for ${reqId} - ${taskId}
-
-## Overview
-- Task: ${taskId}
-- Files to test: ${fileList}
-- Test strategy: ${strategy}
-- Coverage target: ${coverageTarget}%
-
-## Test Categories
-
-### Unit Tests
-#### File: ${fileName}
-- Function: `${functionName}()`
-  - Test: should handle valid input
-  - Test: should reject invalid input
-  - Test: should handle edge cases
-  - Expected coverage: 90%
-
-### Integration Tests
-- API endpoint testing
-- Database interaction testing
-- Third-party service integration
-
-### End-to-End Tests
-- User journey: ${userStory}
-- Critical path: ${criticalPath}
-
-## Test Implementation Guide (for main agent)
-
-### Test File Structure
-```
-tests/
-├── unit/
-│   └── ${fileName}.test.js
-├── integration/
-│   └── ${feature}.integration.test.js
-└── e2e/
-    └── ${userJourney}.e2e.test.js
-```javascript
-
-### Sample Test Code
-```javascript
-// Unit test example for main agent to implement
-describe('${functionName}', () => {
-  it('should ${expectedBehavior}', () => {
-    // Arrange
-    const input = ${testInput};
-
-    // Act
-    const result = ${functionName}(input);
-
-    // Assert
-    expect(result).to${expectedAssertion};
-  });
-});
-```
-
-## Quality Gates
-- [ ] Unit test coverage ≥ ${unitThreshold}%
-- [ ] Integration test coverage ≥ ${integrationThreshold}%
-- [ ] All tests pass consistently
-- [ ] Performance within limits
-- [ ] No security test failures
-
-## Execution Commands (for main agent)
-- Run unit tests: `npm run test:unit`
-- Run integration tests: `npm run test:integration`
-- Run coverage: `npm run test:coverage`
-- Run all tests: `npm test`
-```bash
-
-### 2. Test Report Template (`devflow/requirements/${reqId}/TEST_REPORT.md`)
-Template for main agent to fill after test execution:
-
-```markdown
-# Test Execution Report for ${reqId}
-
-## Test Results Summary
-- Total tests: ${totalTests}
-- Passed: ${passedTests}
-- Failed: ${failedTests}
-- Coverage: ${coveragePercentage}%
-- Execution time: ${executionTime}
-
-## Coverage Analysis
-- Line coverage: ${lineCoverage}%
-- Branch coverage: ${branchCoverage}%
-- Function coverage: ${functionCoverage}%
-
-## Quality Gates Status
-- [ ] Coverage threshold met
-- [ ] All tests passing
-- [ ] Performance acceptable
-- [ ] Security tests passed
-
-## Next Steps
-${nextSteps}
-```
-
-Analysis workflow:
-1. **Implementation Review**: Read and understand task implementation
-2. **Test Strategy Design**: Create comprehensive test coverage plan
-3. **Test Template Generation**: Provide specific test code examples
-4. **Quality Gate Definition**: Set measurable success criteria
-5. **Execution Plan**: Create step-by-step testing guide for main agent
-6. **Report Template**: Prepare template for test results documentation
-
-Remember: You are a test strategist and planner. The main agent will execute all the actual test implementation and execution based on your detailed plans and templates.