claude-code-workflow 6.2.3 → 6.2.5

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

@@ -1,297 +0,0 @@
----
-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

@@ -1,153 +0,0 @@
----
-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

@@ -1,96 +0,0 @@
----
-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

@@ -1,61 +0,0 @@
----
-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
-```