claude-code-workflow 6.2.5 → 6.2.6

package/.claude/commands/workflow/review.md

@@ -0,0 +1,297 @@
+---
+name: review
+description: Post-implementation review with specialized types (security/architecture/action-items/quality) using analysis agents and Gemini
+argument-hint: "[--type=security|architecture|action-items|quality] [optional: session-id]"
+---
+
+## Command Overview: /workflow:review
+
+**Optional specialized review** for completed implementations. In the standard workflow, **passing tests = approved code**. Use this command only when specialized review is required (security, architecture, compliance, docs).
+
+## Philosophy: "Tests Are the Review"
+
+- **Default**: All tests pass -> Code approved
+- **Optional**: Specialized reviews for:
+  - Security audits (vulnerabilities, auth/authz)
+  - Architecture compliance (patterns, technical debt)
+  - Action items verification (requirements met, acceptance criteria)
+
+## Review Types
+
+| Type | Focus | Use Case |
+|------|-------|----------|
+| `quality` | Code quality, best practices, maintainability | Default general review |
+| `security` | Security vulnerabilities, data handling, access control | Security audits |
+| `architecture` | Architectural patterns, technical debt, design decisions | Architecture compliance |
+| `action-items` | Requirements met, acceptance criteria verified, action items completed | Pre-deployment verification |
+
+**Notes**:
+- For documentation generation, use `/workflow:tools:docs`
+- For CLAUDE.md updates, use `/update-memory-related`
+
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse --type flag (default: quality)
+   └─ Parse session-id argument (optional)
+
+Step 1: Session Resolution
+   └─ Decision:
+      ├─ session-id provided → Use provided session
+      └─ Not provided → Auto-detect from .workflow/active/
+
+Step 2: Validation
+   ├─ Check session directory exists
+   └─ Check for completed implementation (.summaries/IMPL-*.md exists)
+
+Step 3: Type Check
+   └─ Decision:
+      ├─ type=docs → Redirect to /workflow:tools:docs
+      └─ Other types → Continue to analysis
+
+Step 4: Model Analysis Phase
+   ├─ Load context (summaries, test results, changed files)
+   └─ Perform specialized review by type:
+      ├─ security → Security patterns + Gemini analysis
+      ├─ architecture → Qwen architecture analysis
+      ├─ quality → Gemini code quality analysis
+      └─ action-items → Requirements verification
+
+Step 5: Generate Report
+   └─ Output: REVIEW-{type}.md
+```
+
+## Execution Template
+
+```bash
+#!/bin/bash
+# Optional specialized review for completed implementation
+
+# Step 1: Session ID resolution
+if [ -n "$SESSION_ARG" ]; then
+    sessionId="$SESSION_ARG"
+else
+    sessionId=$(find .workflow/active/ -name "WFS-*" -type d | head -1 | xargs basename)
+fi
+
+# Step 2: Validation
+if [ ! -d ".workflow/active/${sessionId}" ]; then
+    echo "Session ${sessionId} not found"
+    exit 1
+fi
+
+# Check for completed tasks
+if [ ! -d ".workflow/active/${sessionId}/.summaries" ] || [ -z "$(find .workflow/active/${sessionId}/.summaries/ -name "IMPL-*.md" -type f 2>/dev/null)" ]; then
+    echo "No completed implementation found. Complete implementation first"
+    exit 1
+fi
+
+# Step 3: Determine review type (default: quality)
+review_type="${TYPE_ARG:-quality}"
+
+# Redirect docs review to specialized command
+if [ "$review_type" = "docs" ]; then
+    echo "For documentation generation, please use:"
+    echo "   /workflow:tools:docs"
+    echo ""
+    echo "The docs command provides:"
+    echo "  - Hierarchical architecture documentation"
+    echo "  - API documentation generation"
+    echo "  - Documentation structure analysis"
+    exit 0
+fi
+
+# Step 4: Analysis handover → Model takes control
+# BASH_EXECUTION_STOPS → MODEL_ANALYSIS_BEGINS
+```
+
+### Model Analysis Phase
+
+After bash validation, the model takes control to:
+
+1. **Load Context**: Read completed task summaries and changed files
+   ```bash
+   # Load implementation summaries (iterate through .summaries/ directory)
+   for summary in .workflow/active/${sessionId}/.summaries/*.md; do
+     cat "$summary"
+   done
+
+   # Load test results (if available)
+   for test_summary in .workflow/active/${sessionId}/.summaries/TEST-FIX-*.md 2>/dev/null; do
+     cat "$test_summary"
+   done
+
+   # Get changed files
+   git log --since="$(cat .workflow/active/${sessionId}/workflow-session.json | jq -r .created_at)" --name-only --pretty=format: | sort -u
+   ```
+
+2. **Perform Specialized Review**: Based on `review_type`
+
+   **Security Review** (`--type=security`):
+   - Use ripgrep for security patterns:
+     ```bash
+     rg "password|token|secret|auth" -g "*.{ts,js,py}"
+     rg "eval|exec|innerHTML|dangerouslySetInnerHTML" -g "*.{ts,js,tsx}"
+     ```
+   - Use Gemini for security analysis:
+     ```bash
+     ccw cli -p "
+     PURPOSE: Security audit of completed implementation
+     TASK: Review code for security vulnerabilities, insecure patterns, auth/authz issues
+     CONTEXT: @.summaries/IMPL-*.md,../.. @../../CLAUDE.md
+     EXPECTED: Security findings report with severity levels
+     RULES: Focus on OWASP Top 10, authentication, authorization, data validation, injection risks
+     " --tool gemini --mode write --cd .workflow/active/${sessionId}
+     ```
+
+   **Architecture Review** (`--type=architecture`):
+   - Use Qwen for architecture analysis:
+     ```bash
+     ccw cli -p "
+     PURPOSE: Architecture compliance review
+     TASK: Evaluate adherence to architectural patterns, identify technical debt, review design decisions
+     CONTEXT: @.summaries/IMPL-*.md,../.. @../../CLAUDE.md
+     EXPECTED: Architecture assessment with recommendations
+     RULES: Check for patterns, separation of concerns, modularity, scalability
+     " --tool qwen --mode write --cd .workflow/active/${sessionId}
+     ```
+
+   **Quality Review** (`--type=quality`):
+   - Use Gemini for code quality:
+     ```bash
+     ccw cli -p "
+     PURPOSE: Code quality and best practices review
+     TASK: Assess code readability, maintainability, adherence to best practices
+     CONTEXT: @.summaries/IMPL-*.md,../.. @../../CLAUDE.md
+     EXPECTED: Quality assessment with improvement suggestions
+     RULES: Check for code smells, duplication, complexity, naming conventions
+     " --tool gemini --mode write --cd .workflow/active/${sessionId}
+     ```
+
+   **Action Items Review** (`--type=action-items`):
+   - Verify all requirements and acceptance criteria met:
+     ```bash
+     # Load task requirements and acceptance criteria
+     for task_file in .workflow/active/${sessionId}/.task/*.json; do
+       cat "$task_file" | jq -r '
+         "Task: " + .id + "\n" +
+         "Requirements: " + (.context.requirements | join(", ")) + "\n" +
+         "Acceptance: " + (.context.acceptance | join(", "))
+       '
+     done
+
+     # Check implementation summaries against requirements
+     ccw cli -p "
+     PURPOSE: Verify all requirements and acceptance criteria are met
+     TASK: Cross-check implementation summaries against original requirements
+     CONTEXT: @.task/IMPL-*.json,.summaries/IMPL-*.md,../.. @../../CLAUDE.md
+     EXPECTED:
+     - Requirements coverage matrix
+     - Acceptance criteria verification
+     - Missing/incomplete action items
+     - Pre-deployment readiness assessment
+     RULES:
+     - Check each requirement has corresponding implementation
+     - Verify all acceptance criteria are met
+     - Flag any incomplete or missing action items
+     - Assess deployment readiness
+     " --tool gemini --mode write --cd .workflow/active/${sessionId}
+     ```
+
+
+3. **Generate Review Report**: Create structured report
+   ```markdown
+   # Review Report: ${review_type}
+
+   **Session**: ${sessionId}
+   **Date**: $(date)
+   **Type**: ${review_type}
+
+   ## Summary
+   - Tasks Reviewed: [count IMPL tasks]
+   - Files Changed: [count files]
+   - Severity: [High/Medium/Low]
+
+   ## Findings
+
+   ### Critical Issues
+   - [Issue 1 with file:line reference]
+   - [Issue 2 with file:line reference]
+
+   ### Recommendations
+   - [Recommendation 1]
+   - [Recommendation 2]
+
+   ### Positive Observations
+   - [Good pattern observed]
+
+   ## Action Items
+   - [ ] [Action 1]
+   - [ ] [Action 2]
+   ```
+
+4. **Output Files**:
+   ```bash
+   # Save review report
+   Write(.workflow/active/${sessionId}/REVIEW-${review_type}.md)
+
+   # Update session metadata
+   # (optional) Update workflow-session.json with review status
+   ```
+
+5. **Optional: Update Memory** (if docs review or significant findings):
+   ```bash
+   # If architecture or quality issues found, suggest memory update
+   if [ "$review_type" = "architecture" ] || [ "$review_type" = "quality" ]; then
+       echo "Consider updating project documentation:"
+       echo "   /update-memory-related"
+   fi
+   ```
+
+## Usage Examples
+
+```bash
+# General quality review after implementation
+/workflow:review
+
+# Security audit before deployment
+/workflow:review --type=security
+
+# Architecture review for specific session
+/workflow:review --type=architecture WFS-payment-integration
+
+# Documentation review
+/workflow:review --type=docs
+```
+
+## Features
+
+- **Simple Validation**: Check session exists and has completed tasks
+- **No Complex Orchestration**: Direct analysis, no multi-phase pipeline
+- **Specialized Reviews**: Different prompts and tools for different review types
+- **MCP Integration**: Fast code search for security and architecture patterns
+- **CLI Tool Integration**: Gemini for analysis, Qwen for architecture
+- **Structured Output**: Markdown reports with severity levels and action items
+- **Optional Memory Update**: Suggests documentation updates for significant findings
+
+## Integration with Workflow
+
+```
+Standard Workflow:
+  plan -> execute -> test-gen -> execute (complete)
+
+Optional Review (when needed):
+  plan -> execute -> test-gen -> execute -> review (security/architecture/docs)
+```
+
+**When to Use**:
+- Before production deployment (security review + action-items review)
+- After major feature (architecture review)
+- Before code freeze (quality review)
+- Pre-deployment verification (action-items review)
+
+**When NOT to Use**:
+- Regular development (tests are sufficient)
+- Simple bug fixes (test-fix-agent handles it)
+- Minor changes (update-memory-related is enough)

package/.claude/commands/workflow/session/complete.md

@@ -0,0 +1,153 @@
+---
+name: complete
+description: Mark active workflow session as complete, archive with lessons learned, update manifest, remove active flag
+examples:
+  - /workflow:session:complete
+  - /workflow:session:complete --detailed
+---
+
+# Complete Workflow Session (/workflow:session:complete)
+
+Mark the currently active workflow session as complete, archive it, and update manifests.
+
+## Pre-defined Commands
+
+```bash
+# Phase 1: Find active session
+SESSION_PATH=$(find .workflow/active/ -maxdepth 1 -name "WFS-*" -type d | head -1)
+SESSION_ID=$(basename "$SESSION_PATH")
+
+# Phase 3: Move to archive
+mkdir -p .workflow/archives/
+mv .workflow/active/$SESSION_ID .workflow/archives/$SESSION_ID
+
+# Cleanup marker
+rm -f .workflow/archives/$SESSION_ID/.archiving
+```
+
+## Key Files to Read
+
+**For manifest.json generation**, read ONLY these files:
+
+| File | Extract |
+|------|---------|
+| `$SESSION_PATH/workflow-session.json` | session_id, description, started_at, status |
+| `$SESSION_PATH/IMPL_PLAN.md` | title (first # heading), description (first paragraph) |
+| `$SESSION_PATH/.tasks/*.json` | count files |
+| `$SESSION_PATH/.summaries/*.md` | count files |
+| `$SESSION_PATH/.review/dimensions/*.json` | count + findings summary (optional) |
+
+## Execution Flow
+
+### Phase 1: Find Session (2 commands)
+
+```bash
+# 1. Find and extract session
+SESSION_PATH=$(find .workflow/active/ -maxdepth 1 -name "WFS-*" -type d | head -1)
+SESSION_ID=$(basename "$SESSION_PATH")
+
+# 2. Check/create archiving marker
+test -f "$SESSION_PATH/.archiving" && echo "RESUMING" || touch "$SESSION_PATH/.archiving"
+```
+
+**Output**: `SESSION_ID` = e.g., `WFS-auth-feature`
+
+### Phase 2: Generate Manifest Entry (Read-only)
+
+Read the key files above, then build this structure:
+
+```json
+{
+  "session_id": "<from workflow-session.json>",
+  "description": "<from workflow-session.json>",
+  "archived_at": "<current ISO timestamp>",
+  "archive_path": ".workflow/archives/<SESSION_ID>",
+  "metrics": {
+    "duration_hours": "<(completed_at - started_at) / 3600000>",
+    "tasks_completed": "<count .tasks/*.json>",
+    "summaries_generated": "<count .summaries/*.md>",
+    "review_metrics": {
+      "dimensions_analyzed": "<count .review/dimensions/*.json>",
+      "total_findings": "<sum from dimension JSONs>"
+    }
+  },
+  "tags": ["<3-5 keywords from IMPL_PLAN.md>"],
+  "lessons": {
+    "successes": ["<key wins>"],
+    "challenges": ["<difficulties>"],
+    "watch_patterns": ["<patterns to monitor>"]
+  }
+}
+```
+
+**Lessons Generation**: Use gemini with `~/.claude/workflows/cli-templates/prompts/archive/analysis-simple.txt`
+
+### Phase 3: Atomic Commit (4 commands)
+
+```bash
+# 1. Create archive directory
+mkdir -p .workflow/archives/
+
+# 2. Move session
+mv .workflow/active/$SESSION_ID .workflow/archives/$SESSION_ID
+
+# 3. Update manifest.json (Read → Append → Write)
+# Read: .workflow/archives/manifest.json (or [])
+# Append: archive_entry from Phase 2
+# Write: updated JSON
+
+# 4. Remove marker
+rm -f .workflow/archives/$SESSION_ID/.archiving
+```
+
+**Output**:
+```
+✓ Session "$SESSION_ID" archived successfully
+  Location: .workflow/archives/$SESSION_ID/
+  Manifest: Updated with N total sessions
+```
+
+### Phase 4: Update project.json (Optional)
+
+**Skip if**: `.workflow/project.json` doesn't exist
+
+```bash
+# Check
+test -f .workflow/project.json || echo "SKIP"
+```
+
+**If exists**, add feature entry:
+
+```json
+{
+  "id": "<slugified title>",
+  "title": "<from IMPL_PLAN.md>",
+  "status": "completed",
+  "tags": ["<from Phase 2>"],
+  "timeline": { "implemented_at": "<date>" },
+  "traceability": { "session_id": "<SESSION_ID>", "archive_path": "<path>" }
+}
+```
+
+**Output**:
+```
+✓ Feature added to project registry
+```
+
+## Error Recovery
+
+| Phase | Symptom | Recovery |
+|-------|---------|----------|
+| 1 | No active session | `No active session found` |
+| 2 | Analysis fails | Remove marker: `rm $SESSION_PATH/.archiving`, retry |
+| 3 | Move fails | Session safe in active/, fix issue, retry |
+| 3 | Manifest fails | Session in archives/, manually add entry, remove marker |
+
+## Quick Reference
+
+```
+Phase 1: find session → create .archiving marker
+Phase 2: read key files → build manifest entry (no writes)
+Phase 3: mkdir → mv → update manifest.json → rm marker
+Phase 4: update project.json features array (optional)
+```

package/.claude/commands/workflow/session/list.md

@@ -0,0 +1,96 @@
+---
+name: list
+description: List all workflow sessions with status filtering, shows session metadata and progress information
+examples:
+  - /workflow:session:list
+---
+
+# List Workflow Sessions (/workflow:session:list)
+
+## Overview
+Display all workflow sessions with their current status, progress, and metadata.
+
+## Usage
+```bash
+/workflow:session:list       # Show all sessions with status
+```
+
+## Implementation Flow
+
+### Step 1: Find All Sessions
+```bash
+ls .workflow/active/WFS-* 2>/dev/null
+```
+
+### Step 2: Check Active Session
+```bash
+find .workflow/active/ -name "WFS-*" -type d 2>/dev/null | head -1
+```
+
+### Step 3: Read Session Metadata
+```bash
+jq -r '.session_id, .status, .project' .workflow/active/WFS-session/workflow-session.json
+```
+
+### Step 4: Count Task Progress
+```bash
+find .workflow/active/WFS-session/.task/ -name "*.json" -type f 2>/dev/null | wc -l
+find .workflow/active/WFS-session/.summaries/ -name "*.md" -type f 2>/dev/null | wc -l
+```
+
+### Step 5: Get Creation Time
+```bash
+jq -r '.created_at // "unknown"' .workflow/active/WFS-session/workflow-session.json
+```
+
+## Simple Bash Commands
+
+### Basic Operations
+- **List sessions**: `find .workflow/active/ -name "WFS-*" -type d`
+- **Find active**: `find .workflow/active/ -name "WFS-*" -type d`
+- **Read session data**: `jq -r '.session_id, .status' session.json`
+- **Count tasks**: `find .task/ -name "*.json" -type f | wc -l`
+- **Count completed**: `find .summaries/ -name "*.md" -type f 2>/dev/null | wc -l`
+- **Get timestamp**: `jq -r '.created_at' session.json`
+
+## Simple Output Format
+
+### Session List Display
+```
+Workflow Sessions:
+
+[ACTIVE] WFS-oauth-integration
+   Project: OAuth2 authentication system
+   Status: active
+   Progress: 3/8 tasks completed
+   Created: 2025-09-15T10:30:00Z
+
+[PAUSED] WFS-user-profile
+   Project: User profile management
+   Status: paused
+   Progress: 1/5 tasks completed
+   Created: 2025-09-14T14:15:00Z
+
+[COMPLETED] WFS-database-migration
+   Project: Database schema migration
+   Status: completed
+   Progress: 4/4 tasks completed
+   Created: 2025-09-13T09:00:00Z
+
+Total: 3 sessions (1 active, 1 paused, 1 completed)
+```
+
+### Status Indicators
+- **[ACTIVE]**: Active session
+- **[PAUSED]**: Paused session
+- **[COMPLETED]**: Completed session
+- **[ERROR]**: Error/corrupted session
+
+### Quick Commands
+```bash
+# Count all sessions
+ls .workflow/active/WFS-* | wc -l
+
+# Show recent sessions
+ls -t .workflow/active/WFS-*/workflow-session.json | head -3
+```

package/.claude/commands/workflow/session/resume.md

@@ -0,0 +1,61 @@
+---
+name: resume
+description: Resume the most recently paused workflow session with automatic session discovery and status update
+---
+
+# Resume Workflow Session (/workflow:session:resume)
+
+## Overview
+Resume the most recently paused workflow session, restoring all context and state.
+
+## Usage
+```bash
+/workflow:session:resume     # Resume most recent paused session
+```
+
+## Implementation Flow
+
+### Step 1: Find Paused Sessions
+```bash
+ls .workflow/active/WFS-* 2>/dev/null
+```
+
+### Step 2: Check Session Status
+```bash
+jq -r '.status' .workflow/active/WFS-session/workflow-session.json
+```
+
+### Step 3: Find Most Recent Paused
+```bash
+ls -t .workflow/active/WFS-*/workflow-session.json | head -1
+```
+
+### Step 4: Update Session Status
+```bash
+jq '.status = "active"' .workflow/active/WFS-session/workflow-session.json > temp.json
+mv temp.json .workflow/active/WFS-session/workflow-session.json
+```
+
+### Step 5: Add Resume Timestamp
+```bash
+jq '.resumed_at = "'$(date -u +%Y-%m-%dT%H:%M:%SZ)'"' .workflow/active/WFS-session/workflow-session.json > temp.json
+mv temp.json .workflow/active/WFS-session/workflow-session.json
+```
+
+## Simple Bash Commands
+
+### Basic Operations
+- **List sessions**: `ls .workflow/active/WFS-*`
+- **Check status**: `jq -r '.status' session.json`
+- **Find recent**: `ls -t .workflow/active/*/workflow-session.json | head -1`
+- **Update status**: `jq '.status = "active"' session.json > temp.json`
+- **Add timestamp**: `jq '.resumed_at = "'$(date -u +%Y-%m-%dT%H:%M:%SZ)'"'`
+
+### Resume Result
+```
+Session WFS-user-auth resumed
+- Status: active
+- Paused at: 2025-09-15T14:30:00Z
+- Resumed at: 2025-09-15T15:45:00Z
+- Ready for: /workflow:execute
+```