@the-bearded-bear/claude-craft 8.23.3 → 8.26.0-next.2a54921

package/Project/i18n/en/commands/generate-prd.md

@@ -1,214 +1,9 @@
 ---
-name: generate-prd
-description: Generate a Product Requirements Document from project context and specifications
-arguments:
-  - name: source
-    description: Source file with specifications (optional, default auto-detect)
-    required: false
-  - name: output
-    description: Output path (default project-management/prd.md)
-    required: false
+description: "Deprecated (removed in 9.0): use /workflow:plan --only=prd"
+deprecated: true
+replaced-by: /workflow:plan
 ---
 
-# /project:generate-prd
+> ⚠️ `/project:generate-prd` is deprecated and will be removed in 9.0. Use `/workflow:plan --only=prd`.
 
-## Mission
-
-Generate a comprehensive Product Requirements Document (PRD) by analyzing the project context, existing specifications, and through interactive clarification with the user.
-
-## Prerequisites
-
-- Project directory exists
-- Optional: `./docs/` with existing specifications
-- Optional: `README.md` with project description
-
-## Plan Mode
-
-> **Plan mode is mandatory.** Before executing, Claude activates plan mode to analyze impacted code, propose an implementation plan, and wait for your validation before making any changes.
-
-## Workflow
-
-### Phase 1: Context Discovery
-
-```
-╔══════════════════════════════════════════════════════════╗
-║              PRD GENERATION - DISCOVERY                   ║
-╠══════════════════════════════════════════════════════════╣
-║ Scanning project context...                               ║
-╚══════════════════════════════════════════════════════════╝
-```
-
-**Automatic Analysis:**
-1. Read `README.md` for project overview
-2. Scan `./docs/` for existing specifications
-3. Check `project-management/personas.md` if exists
-4. Analyze codebase structure for tech stack
-5. Review previous conversations for context
-
-**Sources Found:**
-- [ ] README.md
-- [ ] docs/specifications.md
-- [ ] docs/requirements.md
-- [ ] project-management/personas.md
-- [ ] Conversation history
-
-### Phase 2: Interactive Clarification
-
-Ask the user clarifying questions to fill gaps:
-
-#### Problem & Opportunity
-```
-┌─────────────────────────────────────────────────────────┐
-│ QUESTIONS - Problem Statement                            │
-├─────────────────────────────────────────────────────────┤
-│ 1. What problem are you solving?                         │
-│ 2. Who experiences this problem most?                    │
-│ 3. What happens if this problem isn't solved?            │
-│ 4. What's the business opportunity?                      │
-└─────────────────────────────────────────────────────────┘
-```
-
-#### Target Users
-```
-┌─────────────────────────────────────────────────────────┐
-│ QUESTIONS - Target Users                                 │
-├─────────────────────────────────────────────────────────┤
-│ 1. Who are your primary users? (role, demographics)      │
-│ 2. What are their main goals?                            │
-│ 3. What frustrates them with current solutions?          │
-│ 4. Are there secondary user types?                       │
-└─────────────────────────────────────────────────────────┘
-```
-
-#### Goals & Metrics
-```
-┌─────────────────────────────────────────────────────────┐
-│ QUESTIONS - Success Metrics                              │
-├─────────────────────────────────────────────────────────┤
-│ 1. What are your business goals?                         │
-│ 2. How will you measure success? (KPIs)                  │
-│ 3. What are the target values and timeline?              │
-│ 4. What does MVP success look like?                      │
-└─────────────────────────────────────────────────────────┘
-```
-
-#### Requirements & Constraints
-```
-┌─────────────────────────────────────────────────────────┐
-│ QUESTIONS - Scope & Constraints                          │
-├─────────────────────────────────────────────────────────┤
-│ 1. What are the must-have features (P0)?                 │
-│ 2. What's explicitly out of scope?                       │
-│ 3. Any technical constraints? (legacy systems, etc.)     │
-│ 4. Budget or timeline constraints?                       │
-│ 5. Compliance requirements? (GDPR, SOC2, etc.)           │
-└─────────────────────────────────────────────────────────┘
-```
-
-### Phase 3: PRD Generation
-
-Using the collected information, generate the PRD:
-
-1. **Load Template**: `./templates/prd.md`
-2. **Fill Sections**: Populate all sections with gathered data
-3. **Generate Personas**: Create detailed persona profiles
-4. **Structure Requirements**: Organize into P0/P1/P2 priorities
-5. **Identify Risks**: Based on constraints and dependencies
-
-### Phase 4: Review & Iteration
-
-```
-╔══════════════════════════════════════════════════════════╗
-║                    PRD GENERATED                          ║
-╠══════════════════════════════════════════════════════════╣
-║ Output: project-management/prd.md                         ║
-║                                                           ║
-║ Sections completed:                                       ║
-║ ✅ Executive Summary                                      ║
-║ ✅ Problem Statement                                      ║
-║ ✅ Goals & Metrics                                        ║
-║ ✅ Target Users (3 personas)                              ║
-║ ✅ Functional Requirements (12 items)                     ║
-║ ✅ Non-Functional Requirements                            ║
-║ ✅ Scope & Constraints                                    ║
-║ ⚠️  Timeline (needs review)                               ║
-║ ✅ Risks & Mitigations                                    ║
-╚══════════════════════════════════════════════════════════╝
-```
-
-**Offer iterations:**
-- "Would you like me to expand any section?"
-- "Should I add more detail to the personas?"
-- "Do you want to adjust the prioritization?"
-
-## Output Structure
-
-```
-project-management/
-├── prd.md                    # Generated PRD
-├── personas.md               # Extracted/created personas
-└── analysis/
-    └── discovery-notes.md    # Notes from discovery phase
-```
-
-## Integration with Workflow
-
-After PRD generation, suggest next steps:
-
-```
-╔══════════════════════════════════════════════════════════╗
-║                     NEXT STEPS                            ║
-╠══════════════════════════════════════════════════════════╣
-║ PRD is ready! Recommended next actions:                   ║
-║                                                           ║
-║ 1. /project:generate-tech-spec    → Technical design      ║
-║ 2. /project:generate-backlog      → Create SCRUM backlog  ║
-║ 3. /workflow:design               → Architecture phase    ║
-╚══════════════════════════════════════════════════════════╝
-```
-
-## Example Session
-
-```
-User: /project:generate-prd
-
-Claude: Starting PRD generation...
-
-📂 Context Discovery
-Found sources:
-- README.md (project overview)
-- docs/brief.md (initial brief)
-
-Let me ask some clarifying questions:
-
-❓ Problem Statement
-1. What specific problem does this product solve?
-> User: Our users spend too much time manually tracking expenses...
-
-❓ Target Users
-2. Who are your primary users?
-> User: Small business owners and freelancers...
-
-[... interactive Q&A continues ...]
-
-✅ PRD Generated!
-Output: project-management/prd.md
-
-The PRD includes:
-- 2 primary personas (Business Owner, Freelancer)
-- 8 P0 requirements, 5 P1 requirements
-- KPIs: Time saved (50%), Error reduction (80%)
-- 4 identified risks with mitigations
-
-Would you like me to:
-1. Expand any section?
-2. Generate the Technical Specification?
-3. Create the product backlog?
-```
-
-## Related Commands
-
-- `/project:generate-tech-spec` - Generate technical specification
-- `/project:generate-backlog` - Create SCRUM backlog from PRD
-- `/workflow:plan` - Full planning phase workflow
-- `/workflow:init` - Initialize project workflow
+Run `/workflow:plan --only=prd $ARGUMENTS`: read `.claude/commands/workflow/plan.md` and follow it with these arguments.

package/Project/i18n/en/commands/generate-tech-spec.md

@@ -1,289 +1,9 @@
 ---
-name: generate-tech-spec
-description: Generate a Technical Specification from PRD and architecture analysis
-arguments:
-  - name: prd
-    description: Path to PRD (default project-management/prd.md)
-    required: false
-  - name: output
-    description: Output path (default project-management/tech-spec.md)
-    required: false
+description: "Deprecated (removed in 9.0): use /workflow:design"
+deprecated: true
+replaced-by: /workflow:design
 ---
 
-# /project:generate-tech-spec
+> ⚠️ `/project:generate-tech-spec` is deprecated and will be removed in 9.0. Use `/workflow:design`.
 
-## Mission
-
-Generate a comprehensive Technical Specification document by analyzing the PRD, existing codebase, and architectural requirements. This document serves as the technical blueprint for implementation.
-
-## Prerequisites
-
-- PRD exists at `project-management/prd.md` or specified path
-- Project directory with codebase (for existing projects)
-- Technology stack identified
-
-## Plan Mode
-
-> **Plan mode is mandatory.** Before executing, Claude activates plan mode to analyze impacted code, propose an implementation plan, and wait for your validation before making any changes.
-
-## Workflow
-
-### Phase 1: PRD Analysis
-
-```
-╔══════════════════════════════════════════════════════════╗
-║           TECH SPEC GENERATION - ANALYSIS                 ║
-╠══════════════════════════════════════════════════════════╣
-║ Loading PRD and analyzing requirements...                 ║
-╚══════════════════════════════════════════════════════════╝
-```
-
-**Extract from PRD:**
-- Functional requirements (features to build)
-- Non-functional requirements (performance, security, scalability)
-- Personas and user journeys
-- Constraints and assumptions
-- Integration requirements
-
-### Phase 2: Codebase Analysis
-
-If existing codebase:
-
-```
-╔══════════════════════════════════════════════════════════╗
-║               CODEBASE ANALYSIS                           ║
-╠══════════════════════════════════════════════════════════╣
-║ Detected Stack:                                           ║
-║ ├── Backend: Symfony 7.x (PHP 8.3)                        ║
-║ ├── Frontend: React 18.x (TypeScript)                     ║
-║ ├── Database: PostgreSQL 16                               ║
-║ ├── Cache: Redis 7.x                                      ║
-║ └── Infrastructure: Docker + Kubernetes                   ║
-║                                                           ║
-║ Existing Patterns:                                        ║
-║ ├── Architecture: Clean Architecture (Hexagonal)          ║
-║ ├── API Style: REST with JSON:API                         ║
-║ ├── Auth: JWT with refresh tokens                         ║
-║ └── Testing: PHPUnit + Jest + Playwright                  ║
-╚══════════════════════════════════════════════════════════╝
-```
-
-For new projects, ask:
-
-```
-┌─────────────────────────────────────────────────────────┐
-│ QUESTIONS - Technology Stack                             │
-├─────────────────────────────────────────────────────────┤
-│ 1. Preferred backend framework? (Symfony/Laravel/Node)   │
-│ 2. Frontend framework? (React/Vue/Angular/None)          │
-│ 3. Database preference? (PostgreSQL/MySQL/MongoDB)       │
-│ 4. Deployment target? (Docker/K8s/Serverless/VPS)        │
-│ 5. Any existing integrations to consider?                │
-└─────────────────────────────────────────────────────────┘
-```
-
-### Phase 3: Architecture Design
-
-**Ask clarifying questions:**
-
-```
-┌─────────────────────────────────────────────────────────┐
-│ QUESTIONS - Architecture Decisions                       │
-├─────────────────────────────────────────────────────────┤
-│ 1. Monolith or Microservices?                            │
-│ 2. API style preference? (REST/GraphQL/gRPC)             │
-│ 3. Expected scale? (users, requests/sec)                 │
-│ 4. Real-time features needed? (WebSockets/SSE)           │
-│ 5. File storage requirements? (S3/local/CDN)             │
-│ 6. Background job processing needs?                      │
-│ 7. Third-party integrations? (payments, email, etc.)     │
-└─────────────────────────────────────────────────────────┘
-```
-
-### Phase 4: Data Model Design
-
-Based on PRD entities, design the data model:
-
-```mermaid
-erDiagram
-    USER ||--o{ ORDER : places
-    USER {
-        uuid id PK
-        string email UK
-        string name
-        enum role
-    }
-    ORDER ||--|{ ORDER_ITEM : contains
-```
-
-**Validate with user:**
-- Entity relationships correct?
-- Missing entities?
-- Indexing strategy appropriate?
-
-### Phase 5: API Design
-
-Generate API endpoints based on requirements:
-
-```
-╔══════════════════════════════════════════════════════════╗
-║               PROPOSED API ENDPOINTS                      ║
-╠══════════════════════════════════════════════════════════╣
-║ Authentication:                                           ║
-║   POST /api/v1/auth/login                                 ║
-║   POST /api/v1/auth/register                              ║
-║   POST /api/v1/auth/refresh                               ║
-║                                                           ║
-║ Users (from Persona: Admin):                              ║
-║   GET    /api/v1/users                                    ║
-║   GET    /api/v1/users/{id}                               ║
-║   PUT    /api/v1/users/{id}                               ║
-║   DELETE /api/v1/users/{id}                               ║
-║                                                           ║
-║ [Based on FR-001] Orders:                                 ║
-║   GET    /api/v1/orders                                   ║
-║   POST   /api/v1/orders                                   ║
-║   GET    /api/v1/orders/{id}                              ║
-╚══════════════════════════════════════════════════════════╝
-```
-
-### Phase 6: Security & Performance
-
-**Security considerations based on NFRs:**
-
-```
-┌─────────────────────────────────────────────────────────┐
-│ SECURITY CHECKLIST                                       │
-├─────────────────────────────────────────────────────────┤
-│ ✅ Authentication: JWT with HttpOnly cookies              │
-│ ✅ Authorization: RBAC with policies                      │
-│ ✅ Data encryption: AES-256 at rest, TLS 1.3 in transit  │
-│ ✅ Input validation: DTO validation + sanitization        │
-│ ✅ Rate limiting: 100 req/min per user                    │
-│ ✅ OWASP Top 10: Mitigations defined                      │
-│ ⚠️  GDPR compliance: Needs data retention policy          │
-└─────────────────────────────────────────────────────────┘
-```
-
-### Phase 7: Generate Tech Spec
-
-Compile all analysis into the Tech Spec document:
-
-1. **Load Template**: `./templates/tech-spec.md`
-2. **Generate Diagrams**: C4, ERD, sequence diagrams
-3. **Document APIs**: Endpoints, payloads, errors
-4. **Define ADRs**: Architecture Decision Records
-5. **Plan Testing**: Strategy and coverage targets
-6. **Design Deployment**: CI/CD and environments
-
-### Phase 8: Review & ADR Creation
-
-```
-╔══════════════════════════════════════════════════════════╗
-║                  TECH SPEC GENERATED                      ║
-╠══════════════════════════════════════════════════════════╣
-║ Output: project-management/tech-spec.md                   ║
-║                                                           ║
-║ Sections completed:                                       ║
-║ ✅ Architecture Overview (C4 diagrams)                    ║
-║ ✅ Technology Stack                                       ║
-║ ✅ Data Model (ERD + schemas)                             ║
-║ ✅ API Design (24 endpoints)                              ║
-║ ✅ Security Considerations                                ║
-║ ✅ Performance & Scalability                              ║
-║ ✅ Testing Strategy                                       ║
-║ ✅ Deployment & CI/CD                                     ║
-║ ✅ Monitoring & Observability                             ║
-║                                                           ║
-║ ADRs Created:                                             ║
-║ • ADR-001: Database choice (PostgreSQL)                   ║
-║ • ADR-002: API style (REST)                               ║
-║ • ADR-003: Authentication (JWT)                           ║
-╚══════════════════════════════════════════════════════════╝
-```
-
-**Offer iterations:**
-- "Want me to detail the caching strategy?"
-- "Should I expand the API documentation?"
-- "Need more detail on the deployment pipeline?"
-
-## Output Structure
-
-```
-project-management/
-├── tech-spec.md              # Generated Tech Spec
-├── architecture/
-│   ├── c4-context.md         # C4 Context diagram
-│   ├── c4-container.md       # C4 Container diagram
-│   └── erd.md                # Entity Relationship Diagram
-└── docs/
-    └── adr/
-        ├── ADR-001-database.md
-        ├── ADR-002-api-style.md
-        └── ADR-003-auth.md
-```
-
-## Integration with Workflow
-
-After Tech Spec generation:
-
-```
-╔══════════════════════════════════════════════════════════╗
-║                     NEXT STEPS                            ║
-╠══════════════════════════════════════════════════════════╣
-║ Tech Spec is ready! Recommended next actions:             ║
-║                                                           ║
-║ 1. /project:generate-backlog   → Create sprint backlog    ║
-║ 2. /workflow:implement         → Start implementation     ║
-║ 3. /project:decompose-tasks    → Break down first sprint  ║
-╚══════════════════════════════════════════════════════════╝
-```
-
-## Example Session
-
-```
-User: /project:generate-tech-spec
-
-Claude: Starting Tech Spec generation...
-
-📄 Loading PRD from project-management/prd.md
-Found 12 functional requirements, 8 non-functional requirements
-
-📂 Analyzing existing codebase...
-Detected: Symfony 7.x + React 18 + PostgreSQL
-
-Let me confirm some architecture decisions:
-
-❓ Architecture
-1. Current API is REST. Keep REST or migrate to GraphQL?
-> User: Keep REST, it works well for us
-
-2. Expected concurrent users at peak?
-> User: Around 500-1000 users
-
-3. Any specific third-party integrations?
-> User: Stripe for payments, SendGrid for emails
-
-[... interactive Q&A continues ...]
-
-✅ Tech Spec Generated!
-Output: project-management/tech-spec.md
-
-Created:
-- C4 diagrams (context + container)
-- ERD with 8 entities
-- 24 API endpoints documented
-- 3 ADRs (database, API style, auth)
-- Testing strategy (80% coverage target)
-- CI/CD pipeline design
-
-Ready to generate the backlog?
-```
-
-## Related Commands
-
-- `/project:generate-prd` - Generate Product Requirements Document
-- `/project:generate-backlog` - Create SCRUM backlog
-- `/common:architecture-decision` - Create individual ADRs
-- `/workflow:design` - Full solutioning phase workflow
-- `/workflow:implement` - Start implementation phase
+Run `/workflow:design $ARGUMENTS`: read `.claude/commands/workflow/design.md` and follow it with these arguments.

package/Project/i18n/en/commands/list-epics.md

@@ -1,95 +1,9 @@
 ---
-description: List EPICs
-argument-hint: [arguments]
+description: "Deprecated (removed in 9.0): use /project:backlog list epic"
+deprecated: true
+replaced-by: /project:backlog
 ---
 
-# List EPICs
+> ⚠️ `/project:list-epics` is deprecated and will be removed in 9.0. Use `/project:backlog list epic`.
 
-Display the list of all EPICs with their status and progress.
-
-## Arguments
-
-$ARGUMENTS (optional, format: [status] [priority])
-- **Status** (optional): todo, in-progress, blocked, done, all (default: all)
-- **Priority** (optional): high, medium, low
-
-## Process
-
-### Step 1: Read EPICs
-
-1. Scan directory `project-management/backlog/epics/`
-2. Read each file EPIC-XXX-*.md
-3. Extract metadata from each EPIC
-
-### Step 2: Filter (if arguments)
-
-Apply requested filters:
-- By status
-- By priority
-
-### Step 3: Calculate statistics
-
-For each EPIC:
-- Count total USs
-- Count USs by status
-- Calculate progress percentage
-
-### Step 4: Display
-
-Generate formatted table with results.
-
-## Output Format
-
-```
-📋 Project EPICs
-
-| ID | Name | Status | Priority | US | Progress |
-|----|-----|--------|----------|-----|-------------|
-| EPIC-001 | Authentication | 🟡 In Progress | High | 5 | ████░░░░░░ 40% |
-| EPIC-002 | Catalog | 🔴 To Do | Medium | 8 | ░░░░░░░░░░ 0% |
-| EPIC-003 | Cart | 🔴 To Do | High | 6 | ░░░░░░░░░░ 0% |
-
-───────────────────────────────────────────────────
-Summary: 3 EPICs | 🔴 2 To Do | 🟡 1 In Progress | 🟢 0 Done
-```
-
-## Compact Format (if many EPICs)
-
-```
-📋 EPICs (12 total)
-
-🔴 To Do (5):
-   EPIC-002, EPIC-003, EPIC-004, EPIC-007, EPIC-010
-
-🟡 In Progress (4):
-   EPIC-001 (40%), EPIC-005 (60%), EPIC-008 (25%), EPIC-011 (80%)
-
-⏸️ Blocked (1):
-   EPIC-006 - Blocked by external dependency
-
-🟢 Done (2):
-   EPIC-009 ✓, EPIC-012 ✓
-```
-
-## Examples
-
-```
-# List all EPICs
-/project:list-epics
-
-# List in-progress EPICs
-/project:list-epics in-progress
-
-# List high priority EPICs
-/project:list-epics all high
-
-# List blocked EPICs
-/project:list-epics blocked
-```
-
-## EPIC Details
-
-To view details of a specific EPIC, suggest:
-```
-View details: cat project-management/backlog/epics/EPIC-001-*.md
-```
+Run `/project:backlog list epic $ARGUMENTS`: read `.claude/commands/project/backlog.md` and follow it with these arguments.