universal-dev-standards 4.1.0 → 4.2.0

package/bundled/skills/claude-code/workflows/code-review.workflow.yaml

@@ -0,0 +1,186 @@
+# Code Review Workflow
+# Comprehensive code review process
+#
+# This workflow guides a thorough code review process,
+# ensuring quality, security, and maintainability.
+
+name: code-review
+version: 1.0.0
+description: |
+  Comprehensive code review workflow for PRs and code changes.
+  Use for thorough review before merging to main branch.
+  Keywords: code review, PR review, pull request, 程式碼審查, PR 審查.
+
+metadata:
+  author: universal-dev-standards
+  category: review
+  difficulty: intermediate
+  estimated_steps: 4
+  related_skills:
+    - code-review-assistant
+    - testing-guide
+    - checkin-assistant
+
+prerequisites:
+  - Pull request created
+  - CI checks passing (or reasons documented)
+  - PR description complete
+
+steps:
+  # Step 1: Context Understanding
+  - id: understand
+    name: Understand Context
+    type: agent
+    agent: spec-analyst
+    description: |
+      Understand the purpose and scope of the changes.
+      Review PR description, linked issues, and specs.
+    inputs:
+      - pr_description
+      - linked_issues
+      - diff_summary
+    outputs:
+      - context_summary
+      - review_focus_areas
+    questions:
+      - What problem does this solve?
+      - What is the expected behavior?
+      - What are the risks?
+
+  # Step 2: Code Quality Review
+  - id: quality-review
+    name: Code Quality Review
+    type: agent
+    agent: reviewer
+    description: |
+      Review code for quality, maintainability, and best practices.
+      Focus on readability, design patterns, and conventions.
+    inputs:
+      - code_changes
+      - context_summary
+    outputs:
+      - quality_report
+      - suggestions
+    checklist:
+      - Code follows project style guide
+      - Functions are appropriately sized
+      - No code duplication
+      - Error handling is appropriate
+      - Naming is clear and consistent
+      - Comments are helpful (not redundant)
+    severity_levels:
+      blocking: Must fix before merge
+      important: Should fix
+      suggestion: Nice to have
+      note: Informational
+
+  # Step 3: Security & Testing Review
+  - id: security-review
+    name: Security & Testing Review
+    type: agent
+    agent: test-specialist
+    description: |
+      Review for security vulnerabilities and test coverage.
+      Ensure changes are properly tested.
+    inputs:
+      - code_changes
+      - existing_tests
+    outputs:
+      - security_report
+      - coverage_assessment
+    security_checks:
+      - No hardcoded secrets
+      - Input validation present
+      - No SQL injection vulnerabilities
+      - No XSS vulnerabilities
+      - Proper authentication/authorization
+      - Dependencies are safe
+    testing_checks:
+      - New code has tests
+      - Edge cases covered
+      - Tests are meaningful (not just coverage)
+      - No flaky tests introduced
+
+  # Step 4: Final Decision
+  - id: decision
+    name: Review Decision
+    type: manual
+    description: |
+      Make final review decision based on findings.
+      Approve, request changes, or discuss.
+    inputs:
+      - quality_report
+      - security_report
+      - coverage_assessment
+    outputs:
+      - review_decision
+      - feedback_comments
+    decisions:
+      approve:
+        condition: No blocking issues
+        action: Approve PR
+      request_changes:
+        condition: Blocking issues found
+        action: Request changes with clear feedback
+      comment:
+        condition: Need clarification
+        action: Add comments and discuss
+    instructions: |
+      When providing feedback:
+      1. Use appropriate prefixes (BLOCKING, IMPORTANT, SUGGESTION)
+      2. Be specific about location and issue
+      3. Suggest solutions when possible
+      4. Be respectful and constructive
+      5. Acknowledge good practices
+
+outputs:
+  - name: review_summary
+    description: Summary of review findings
+    format: markdown
+
+  - name: action_items
+    description: List of changes requested
+    format: checklist
+
+  - name: decision
+    description: Final review decision
+    format: status
+
+# Review comment templates
+comment_templates:
+  blocking: |
+    ❗ BLOCKING: [Issue description]
+
+    [Why this is a problem]
+
+    Suggested fix:
+    ```
+    [code suggestion]
+    ```
+
+  important: |
+    ⚠️ IMPORTANT: [Issue description]
+
+    [Why this should be addressed]
+
+  suggestion: |
+    💡 SUGGESTION: [Improvement idea]
+
+    [Rationale and benefits]
+
+  question: |
+    ❓ QUESTION: [Your question]
+
+    [Context for the question]
+
+  note: |
+    📝 NOTE: [Observation]
+
+    [Additional context]
+
+completion_criteria:
+  - All critical issues addressed or waived
+  - Security review completed
+  - Test coverage acceptable
+  - Review decision documented
+  - Feedback provided constructively

package/bundled/skills/claude-code/workflows/feature-dev.workflow.yaml

@@ -0,0 +1,174 @@
+# Feature Development Workflow
+# Standard workflow for developing new features
+#
+# This workflow guides the development of new features from requirements
+# through implementation and review.
+
+name: feature-dev
+version: 1.0.0
+description: |
+  Standard feature development workflow from requirements to deployment.
+  Use for typical feature work with balanced rigor and efficiency.
+  Keywords: feature, development, implementation, 功能開發, 開發流程.
+
+metadata:
+  author: universal-dev-standards
+  category: development
+  difficulty: intermediate
+  estimated_steps: 6
+  related_skills:
+    - spec-driven-dev
+    - testing-guide
+    - code-review-assistant
+
+prerequisites:
+  - User story or feature request defined
+  - Git branch created (feature/xxx)
+  - Development environment ready
+
+steps:
+  # Step 1: Requirements Analysis
+  - id: analyze
+    name: Analyze Requirements
+    type: agent
+    agent: spec-analyst
+    description: |
+      Analyze the feature request and clarify requirements.
+      Identify acceptance criteria and potential challenges.
+    inputs:
+      - feature_request
+      - existing_codebase_context
+    outputs:
+      - requirements_analysis
+      - acceptance_criteria
+      - technical_considerations
+    checklist:
+      - Requirements understood
+      - Questions clarified
+      - Scope defined
+
+  # Step 2: Architecture Design
+  - id: design
+    name: Design Architecture
+    type: agent
+    agent: code-architect
+    description: |
+      Design the technical architecture for the feature.
+      Identify components, interfaces, and data flow.
+    inputs:
+      - requirements_analysis
+      - existing_architecture
+    outputs:
+      - architecture_design
+      - component_list
+      - api_contracts
+    considerations:
+      - Reuse existing components where possible
+      - Follow project patterns and conventions
+      - Consider performance and scalability
+
+  # Step 3: Test Planning
+  - id: test-plan
+    name: Plan Tests
+    type: agent
+    agent: test-specialist
+    description: |
+      Define testing strategy for the feature.
+      Identify test cases at different levels.
+    inputs:
+      - acceptance_criteria
+      - architecture_design
+    outputs:
+      - test_plan
+      - test_cases
+    test_levels:
+      - unit: Core logic functions
+      - integration: Component interactions
+      - e2e: Critical user paths
+
+  # Step 4: Implementation
+  - id: implement
+    name: Implement Feature
+    type: manual
+    description: |
+      Implement the feature following the design and test plan.
+      Use TDD approach where appropriate.
+    inputs:
+      - architecture_design
+      - test_plan
+    outputs:
+      - implementation_code
+      - tests
+    instructions: |
+      Implementation guidelines:
+      1. Start with tests (TDD recommended)
+      2. Implement core functionality first
+      3. Add edge case handling
+      4. Run tests frequently
+      5. Commit in logical chunks
+    checklist:
+      - Core functionality implemented
+      - Unit tests written and passing
+      - Integration tests passing
+      - No linting errors
+      - Code committed
+
+  # Step 5: Self Review
+  - id: self-review
+    name: Self Code Review
+    type: agent
+    agent: reviewer
+    description: |
+      Perform self-review before requesting peer review.
+      Check for common issues and improvements.
+    inputs:
+      - implementation_code
+      - tests
+    outputs:
+      - self_review_report
+      - improvement_suggestions
+    focus_areas:
+      - Code quality and style
+      - Test coverage
+      - Security considerations
+      - Performance implications
+
+  # Step 6: Documentation
+  - id: document
+    name: Update Documentation
+    type: agent
+    agent: doc-writer
+    description: |
+      Update relevant documentation for the new feature.
+      Include API docs, user guides, and changelog.
+    inputs:
+      - implementation_code
+      - architecture_design
+    outputs:
+      - updated_docs
+      - changelog_entry
+    documentation_types:
+      - API documentation
+      - User-facing documentation
+      - CHANGELOG entry
+      - README updates (if needed)
+
+outputs:
+  - name: feature_branch
+    description: Git branch with implemented feature
+    format: git-branch
+
+  - name: test_suite
+    description: Tests for the feature
+    format: varies
+
+  - name: documentation
+    description: Updated documentation
+    format: markdown
+
+completion_criteria:
+  - All acceptance criteria met
+  - Tests passing
+  - Self-review completed
+  - Documentation updated
+  - Ready for peer review/PR

package/bundled/skills/claude-code/workflows/integrated-flow.workflow.yaml

@@ -0,0 +1,238 @@
+# Integrated Development Flow Workflow
+# Complete ATDD → SDD → BDD → TDD development cycle
+#
+# This workflow orchestrates the full software development lifecycle,
+# integrating acceptance testing, specification, behavior, and test-driven approaches.
+
+name: integrated-flow
+version: 1.0.0
+description: |
+  Complete development workflow integrating ATDD, SDD, BDD, and TDD methodologies.
+  Use for comprehensive feature development with full traceability from requirements to tests.
+  Keywords: ATDD, SDD, BDD, TDD, integrated, full-cycle, 整合流程, 完整開發.
+
+metadata:
+  author: universal-dev-standards
+  category: development
+  difficulty: advanced
+  estimated_steps: 8
+  related_skills:
+    - atdd-assistant
+    - spec-driven-dev
+    - bdd-assistant
+    - tdd-assistant
+
+prerequisites:
+  - Project initialized with UDS standards
+  - Git repository configured
+  - Test framework set up
+  - AI tool with Task support (recommended)
+
+# Workflow execution steps
+steps:
+  # Phase 1: ATDD - Acceptance Test-Driven Development
+  - id: specification-workshop
+    name: Specification Workshop
+    phase: ATDD
+    type: agent
+    agent: spec-analyst
+    description: |
+      Conduct specification workshop to define acceptance criteria.
+      Involves stakeholder collaboration to clarify requirements.
+    inputs:
+      - user_story
+      - business_context
+    outputs:
+      - acceptance_criteria
+      - test_scenarios
+    checklist:
+      - Stakeholders identified
+      - User story clarified
+      - Acceptance criteria in Given-When-Then format
+      - Edge cases documented
+
+  # Phase 2: SDD - Spec-Driven Development
+  - id: spec-proposal
+    name: Specification Proposal
+    phase: SDD
+    type: agent
+    agent: spec-analyst
+    description: |
+      Draft formal specification document based on acceptance criteria.
+      Include technical design, API contracts, and data models.
+    inputs:
+      - acceptance_criteria
+      - test_scenarios
+    outputs:
+      - spec_document
+    template: |
+      # SPEC-XXX: [Feature Name]
+
+      ## Summary
+      [Brief description]
+
+      ## Acceptance Criteria
+      [From workshop]
+
+      ## Technical Design
+      [Architecture, components]
+
+      ## API Contract
+      [Endpoints, data structures]
+
+      ## Risks & Mitigations
+      [Identified risks]
+
+  - id: spec-review
+    name: Specification Review
+    phase: SDD
+    type: manual
+    description: |
+      Review and approve specification document.
+      Ensure technical feasibility and alignment with requirements.
+    inputs:
+      - spec_document
+    outputs:
+      - approved_spec
+    instructions: |
+      Review the specification document:
+      1. Verify technical accuracy
+      2. Check acceptance criteria completeness
+      3. Assess risks and mitigations
+      4. Approve or request changes
+    checklist:
+      - Technical design is sound
+      - Acceptance criteria are testable
+      - Risks are acceptable
+      - Stakeholders approved
+
+  # Phase 3: BDD - Behavior-Driven Development
+  - id: discovery
+    name: BDD Discovery
+    phase: BDD
+    type: agent
+    agent: test-specialist
+    description: |
+      Discover and formulate BDD scenarios from approved spec.
+      Generate Gherkin feature files.
+    inputs:
+      - approved_spec
+    outputs:
+      - feature_files
+      - scenario_outlines
+    example_output: |
+      Feature: User Authentication
+        As a user
+        I want to log in with my credentials
+        So that I can access my account
+
+        Scenario: Successful login
+          Given I am on the login page
+          When I enter valid credentials
+          Then I should be redirected to dashboard
+
+  - id: formulation
+    name: BDD Formulation
+    phase: BDD
+    type: manual
+    description: |
+      Review and refine BDD scenarios with stakeholders.
+      Ensure scenarios are clear and testable.
+    inputs:
+      - feature_files
+    outputs:
+      - refined_features
+    checklist:
+      - Scenarios cover all acceptance criteria
+      - Language is clear to all stakeholders
+      - Examples are realistic
+      - Edge cases included
+
+  # Phase 4: TDD - Test-Driven Development
+  - id: tdd-red
+    name: TDD Red Phase
+    phase: TDD
+    type: agent
+    agent: test-specialist
+    description: |
+      Write failing tests based on BDD scenarios.
+      Tests should be minimal and focused.
+    inputs:
+      - refined_features
+    outputs:
+      - failing_tests
+    instructions: |
+      For each BDD scenario:
+      1. Write unit test that captures behavior
+      2. Run test to verify it fails
+      3. Document test purpose
+
+  - id: tdd-green
+    name: TDD Green Phase
+    phase: TDD
+    type: manual
+    description: |
+      Implement minimum code to make tests pass.
+      Focus on functionality, not optimization.
+    inputs:
+      - failing_tests
+    outputs:
+      - passing_implementation
+    instructions: |
+      Implementation guidelines:
+      1. Write minimum code to pass tests
+      2. Do not optimize yet
+      3. Commit when tests pass
+    checklist:
+      - All tests pass
+      - No extra functionality added
+      - Code committed
+
+  - id: tdd-refactor
+    name: TDD Refactor Phase
+    phase: TDD
+    type: agent
+    agent: reviewer
+    description: |
+      Refactor implementation while maintaining passing tests.
+      Review code quality and suggest improvements.
+    inputs:
+      - passing_implementation
+    outputs:
+      - refactored_code
+      - review_report
+    checklist:
+      - Code follows project standards
+      - No code duplication
+      - Tests still pass
+      - Documentation updated
+
+# Final outputs
+outputs:
+  - name: spec_document
+    description: Approved specification document
+    format: markdown
+    path: specs/SPEC-XXX.md
+
+  - name: feature_files
+    description: BDD feature files
+    format: gherkin
+    path: features/
+
+  - name: test_suite
+    description: TDD test files
+    format: varies
+    path: tests/
+
+  - name: implementation
+    description: Refactored implementation
+    format: varies
+    path: src/
+
+# Workflow completion criteria
+completion_criteria:
+  - All acceptance criteria met
+  - All tests passing
+  - Code reviewed and approved
+  - Documentation updated
+  - Spec archived with links to implementation