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

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

@@ -1,288 +1,9 @@
 ---
-name: reverse-prd
-description: Generate a PRD from an existing codebase by analyzing implemented features and business logic
-arguments:
-  - name: scan-report
-    description: Path to scan report (default project-management/scan-report.md)
-    required: false
-  - name: output
-    description: Output path (default project-management/prd.md)
-    required: false
+description: "Deprecated (removed in 9.0): use /project:reverse prd"
+deprecated: true
+replaced-by: /project:reverse
 ---
 
-# /project:reverse-prd
+> ⚠️ `/project:reverse-prd` is deprecated and will be removed in 9.0. Use `/project:reverse prd`.
 
-## Mission
-
-Generate a DRAFT Product Requirements Document (PRD) from an existing codebase by analyzing implemented features, business logic, authentication patterns, and infrastructure. This is the brownfield counterpart to `/project:generate-prd` for projects that already have working code but lack formal specifications.
-
-**IMPORTANT:** The output is always a DRAFT. All inferred sections are marked as requiring human validation. This command does NOT create authoritative specifications -- it creates a starting point for discussion and refinement.
-
-## Prerequisites
-
-- Scan report exists at `project-management/scan-report.md` (or run `/project:scan` first)
-- Codebase is accessible for analysis
-- Optional: Existing documentation in `./docs/`
-- 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
-
-### Step 1: Load Scan Report
-
-```
-+--------------------------------------------------------------+
-|              REVERSE PRD - LOADING SCAN                        |
-+--------------------------------------------------------------+
-| Loading scan report...                                         |
-+--------------------------------------------------------------+
-```
-
-**Actions:**
-1. Load `project-management/scan-report.md`
-2. If scan report does not exist, prompt user to run `/project:scan` first
-3. Parse technology stack, modules, endpoints, entities, and services
-4. Load any existing documentation from `./docs/` and `README.md`
-
-### Step 2: Business Logic Analysis
-
-```
-+--------------------------------------------------------------+
-|              REVERSE PRD - BUSINESS ANALYSIS                   |
-+--------------------------------------------------------------+
-| Analyzing business logic from code...                          |
-+--------------------------------------------------------------+
-```
-
-**For each module/bounded context, analyze:**
-
-1. **Domain Events**: What business events are dispatched?
-   - Event classes and their payloads
-   - Event listeners and subscribers
-   - Event-driven workflows
-
-2. **Use Cases / Commands / Queries**: What operations exist?
-   - Command handlers (write operations)
-   - Query handlers (read operations)
-   - Service methods with business logic
-
-3. **Validation Rules**: What constraints exist?
-   - Entity validation (annotations, attributes)
-   - Form/request validation
-   - Business rule assertions
-
-4. **State Machines**: What status transitions exist?
-   - Enum types for statuses
-   - Workflow/state machine configurations
-   - Guard conditions
-
-5. **External Integrations**: What third-party services are used?
-   - Payment gateways
-   - Email/notification services
-   - Storage providers
-   - External APIs
-
-### Step 3: Requirement Inference
-
-```
-+--------------------------------------------------------------+
-|              REVERSE PRD - INFERENCE                            |
-+--------------------------------------------------------------+
-| Inferring requirements from code...                            |
-+--------------------------------------------------------------+
-```
-
-**Inference Rules:**
-
-| Code Pattern | Inferred Requirement |
-|-------------|---------------------|
-| Auth middleware / JWT | User authentication required |
-| Role-based guards | Authorization with roles |
-| CRUD controllers | Data management features |
-| File upload handlers | Document/media management |
-| Email services | Notification system |
-| Payment gateway | Payment processing |
-| Export endpoints | Reporting/export features |
-| Search/filter logic | Search and filtering |
-| Pagination | Large dataset handling |
-| Cache layers | Performance requirements |
-| Queue workers | Async processing requirements |
-| Rate limiting | API protection requirements |
-
-**Persona Inference from Auth Patterns:**
-
-| Auth Pattern | Inferred Persona |
-|-------------|-----------------|
-| `ROLE_ADMIN` | Administrator persona |
-| `ROLE_USER` | Standard user persona |
-| `ROLE_MANAGER` | Manager/supervisor persona |
-| Public endpoints (no auth) | Anonymous/visitor persona |
-| API key auth | External system/integration persona |
-
-**NFR Inference from Infrastructure:**
-
-| Infrastructure | Inferred NFR |
-|---------------|-------------|
-| Docker / Kubernetes | Scalability, containerization |
-| Redis / Memcached | Performance caching requirements |
-| Queue system (RabbitMQ, etc.) | Async processing, reliability |
-| CI/CD pipelines | Deployment automation |
-| Load balancer config | High availability |
-| SSL/TLS configuration | Security requirements |
-| Logging stack (ELK, etc.) | Monitoring requirements |
-
-### Step 4: PRD Generation
-
-```
-+--------------------------------------------------------------+
-|              REVERSE PRD - GENERATION                          |
-+--------------------------------------------------------------+
-| Generating DRAFT PRD...                                        |
-+--------------------------------------------------------------+
-```
-
-**Generate the PRD with the following sections:**
-
-1. **Executive Summary** -- `INFERRED`
-   - Project name and description from README/code
-   - Technology stack summary
-   - Estimated scope and complexity
-
-2. **Problem Statement** -- `INFERRED`
-   - Inferred from domain model and business logic
-   - Marked for human validation
-
-3. **Goals & Metrics** -- `PLACEHOLDER`
-   - Cannot be reliably inferred from code
-   - Placeholder section requiring human input
-
-4. **Target Users / Personas** -- `INFERRED`
-   - Generated from authentication and authorization patterns
-   - Each persona marked as draft
-
-5. **Functional Requirements** -- `INFERRED`
-   - One requirement per feature/endpoint group
-   - Prioritized by code complexity and usage patterns
-   - Each tagged with source module
-
-6. **Non-Functional Requirements** -- `INFERRED`
-   - Inferred from infrastructure and configuration
-   - Performance, security, scalability sections
-
-7. **Scope & Constraints** -- `INFERRED`
-   - Current scope from implemented features
-   - Technical constraints from stack choices
-
-8. **Risks & Mitigations** -- `INFERRED`
-   - Technical debt indicators
-   - Missing test coverage areas
-   - Dependency risks
-
-**Every inferred section includes the marker:**
-```
-> INFERRED -- This section was generated by analyzing the existing codebase.
-> Human validation is required before treating this as an authoritative requirement.
-```
-
-### Step 5: Human Validation
-
-```
-+--------------------------------------------------------------+
-|              REVERSE PRD - VALIDATION                          |
-+--------------------------------------------------------------+
-| DRAFT PRD generated. Human validation required.                |
-+--------------------------------------------------------------+
-```
-
-**Present the draft to the user for validation:**
-1. Display a summary of all inferred sections
-2. Highlight sections with low confidence
-3. Identify sections that could not be inferred (Goals, Metrics)
-4. Ask the user to validate, correct, or expand each section
-5. Iterate until the user is satisfied
-
-## Output Format
-
-```
-project-management/
-+-- prd.md                       # Generated DRAFT PRD
-+-- analysis/
-    +-- reverse-engineering.md   # Analysis notes and confidence levels
-```
-
-**PRD Header:**
-
-```
-+==============================================================+
-|                 REVERSE-ENGINEERED PRD (DRAFT)                 |
-+==============================================================+
-| Project: {name}                                                |
-| Source: Codebase analysis                                      |
-| Status: DRAFT - Requires human validation                      |
-| Generated: {date}                                              |
-+==============================================================+
-| Confidence Levels:                                             |
-| - Executive Summary:       HIGH                                |
-| - Problem Statement:       MEDIUM                              |
-| - Goals & Metrics:         LOW (placeholder)                   |
-| - Personas:                MEDIUM                              |
-| - Functional Requirements: HIGH                                |
-| - Non-Functional Reqs:     MEDIUM                              |
-| - Scope & Constraints:     HIGH                                |
-| - Risks:                   MEDIUM                              |
-+==============================================================+
-```
-
-## Example Session
-
-```
-User: /project:reverse-prd
-
-Claude: Starting reverse PRD generation...
-
-[Loading Scan]
-Loaded scan report: project-management/scan-report.md
-Stack: Symfony 7.2 / PHP 8.4
-Modules: 5 bounded contexts, 23 endpoints, 8 entities
-
-[Business Analysis]
-Analyzing domain events... Found 12 event types
-Analyzing use cases... Found 18 command/query handlers
-Analyzing validation rules... Found 35 constraint annotations
-Analyzing auth patterns... Found 3 role types (ADMIN, MANAGER, USER)
-
-[Inference]
-Inferred 3 personas from auth patterns
-Inferred 14 functional requirements from endpoints
-Inferred 6 non-functional requirements from infrastructure
-
-[Generation]
-DRAFT PRD generated: project-management/prd.md
-
-Summary:
-- 3 personas (Admin, Manager, User) -- INFERRED
-- 14 functional requirements across 5 modules -- INFERRED
-- 6 non-functional requirements -- INFERRED
-- Goals & Metrics -- PLACEHOLDER (needs human input)
-
-Sections requiring your attention:
-1. Goals & Metrics (could not be inferred)
-2. Problem Statement (low confidence)
-3. Persona details (names, demographics)
-
-Would you like to:
-1. Review and validate each section interactively?
-2. Focus on a specific section first?
-3. Export the draft as-is and refine later?
-```
-
-## Related Commands
-
-- `/project:scan` - Scan codebase (prerequisite)
-- `/project:reverse-stories` - Generate user stories from codebase
-- `/project:gap-analysis` - Compare spec vs code
-- `/project:generate-prd` - Generate PRD interactively (greenfield)
-- `/project:generate-backlog` - Create SCRUM backlog from PRD
+Run `/project:reverse prd $ARGUMENTS`: read `.claude/commands/project/reverse.md` and follow it with these arguments.

package/Project/i18n/en/commands/reverse-stories.md

@@ -1,305 +1,9 @@
 ---
-name: reverse-stories
-description: Generate user stories from existing codebase features and endpoints
-arguments:
-  - name: scan-report
-    description: Path to scan report (default project-management/scan-report.md)
-    required: false
-  - name: scope
-    description: Scope to generate stories for (all, module, endpoint)
-    required: false
-  - name: module
-    description: Specific module to generate stories for
-    required: false
+description: "Deprecated (removed in 9.0): use /project:reverse stories"
+deprecated: true
+replaced-by: /project:reverse
 ---
 
-# /project:reverse-stories
+> ⚠️ `/project:reverse-stories` is deprecated and will be removed in 9.0. Use `/project:reverse stories`.
 
-## Mission
-
-Generate user stories from an existing codebase by analyzing implemented features, endpoints, and test assertions. Each story is inferred from actual code behavior and marked as a DRAFT requiring human validation. This command bridges the gap between working code and formal product documentation.
-
-**IMPORTANT:** All generated stories are marked as `INFERRED`. They represent what the code currently does, not necessarily what it should do. Human validation is mandatory before treating these as authoritative requirements.
-
-## Prerequisites
-
-- Scan report exists at `project-management/scan-report.md` (or run `/project:scan` first)
-- Optional: PRD exists at `project-management/prd.md` (from `/project:reverse-prd`)
-- Codebase is accessible for analysis
-- Optional: Existing test files for acceptance criteria extraction
-
-## 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
-
-### Step 1: Load Context
-
-```
-+--------------------------------------------------------------+
-|            REVERSE STORIES - LOADING CONTEXT                   |
-+--------------------------------------------------------------+
-| Loading scan report and PRD...                                 |
-+--------------------------------------------------------------+
-```
-
-**Actions:**
-1. Load `project-management/scan-report.md`
-2. If scan report does not exist, prompt user to run `/project:scan` first
-3. Load `project-management/prd.md` if available (for FR-xxx traceability)
-4. Parse modules, endpoints, entities, services, and test files
-5. Determine scope (all modules, specific module, or specific endpoint)
-
-### Step 2: Feature Extraction
-
-```
-+--------------------------------------------------------------+
-|            REVERSE STORIES - FEATURE EXTRACTION                |
-+--------------------------------------------------------------+
-| Extracting features from code...                               |
-+--------------------------------------------------------------+
-```
-
-**For each endpoint/feature, extract:**
-
-1. **Controller/Handler Analysis**
-   - HTTP method and route path
-   - Request validation rules (DTO, form requests)
-   - Response structure and status codes
-   - Authorization requirements (roles, voters, policies)
-
-2. **Service/Use Case Analysis**
-   - Business logic flow
-   - Side effects (events dispatched, notifications sent)
-   - External service calls
-   - Error handling paths
-
-3. **Entity/Model Analysis**
-   - Fields and their constraints
-   - Relationships and cascading behavior
-   - State transitions (status fields, workflows)
-   - Soft delete, timestamps, versioning
-
-4. **Test Analysis**
-   - Test method names (often describe behavior)
-   - Assertions (define expected outcomes)
-   - Test data fixtures (define valid/invalid inputs)
-   - Edge cases covered
-
-### Step 3: Story Generation
-
-```
-+--------------------------------------------------------------+
-|            REVERSE STORIES - GENERATION                        |
-+--------------------------------------------------------------+
-| Generating user stories...                                     |
-+--------------------------------------------------------------+
-```
-
-**For each feature, generate a user story:**
-
-#### Persona Inference
-- `ROLE_ADMIN` + admin routes -> "As an administrator"
-- `ROLE_USER` + authenticated routes -> "As a registered user"
-- `ROLE_MANAGER` + management routes -> "As a manager"
-- Public routes (no auth) -> "As a visitor"
-- API key routes -> "As an external system"
-
-#### Action Inference
-- `POST /api/resources` -> "I want to create a resource"
-- `GET /api/resources` -> "I want to list resources"
-- `GET /api/resources/{id}` -> "I want to view a resource"
-- `PUT /api/resources/{id}` -> "I want to update a resource"
-- `DELETE /api/resources/{id}` -> "I want to delete a resource"
-- Custom actions -> Inferred from method name and business logic
-
-#### Benefit Inference
-- CRUD operations -> "So that I can manage {resource} data"
-- Search/filter -> "So that I can find relevant {resources} quickly"
-- Export -> "So that I can use {resource} data externally"
-- Notifications -> "So that I am informed about {event}"
-- Auth -> "So that my data is secure and accessible only to me"
-
-#### Acceptance Criteria from Tests
-- Test assertions become Gherkin scenarios
-- Test fixtures define Given conditions
-- Test actions define When conditions
-- Test expectations define Then conditions
-
-**Story Template:**
-
-```markdown
-# US-XXX: [Inferred Title]
-
-> INFERRED -- This story was generated from codebase analysis.
-> Human validation is required.
-
-## Source
-- **Module**: {module_name}
-- **Endpoint**: {method} {path}
-- **Controller**: {controller_class}
-- **Implements**: FR-XXX (if PRD exists)
-
-## User Story
-
-### Card
-**As** [inferred persona]
-**I want** [inferred action]
-**So that** [inferred benefit]
-
-### Conversation
-- [ ] Validate persona assignment
-- [ ] Confirm action description matches intent
-- [ ] Verify benefit aligns with business goals
-
-### INVEST Validation
-- [ ] Independent / Negotiable / Valuable / Estimable / Sized / Testable
-
-## Acceptance Criteria (Gherkin)
-
-### Nominal Scenario (from code behavior)
-Scenario: [Inferred from happy path]
-  Given [initial state from test fixtures]
-  When [action from controller/handler]
-  Then [expected result from assertions]
-
-### Error Scenarios (from validation rules)
-Scenario: [Inferred from validation]
-  Given [context]
-  When [invalid action]
-  Then [error response from code]
-
-## Technical Notes
-- Entity: {entity_name}
-- Validation: {validation_rules}
-- Auth: {auth_requirements}
-- Events: {dispatched_events}
-
-## Estimation
-- **Story Points**: [estimated from complexity]
-- **MoSCoW**: [inferred from usage patterns]
-```
-
-### Step 4: Traceability Mapping
-
-```
-+--------------------------------------------------------------+
-|            REVERSE STORIES - TRACEABILITY                      |
-+--------------------------------------------------------------+
-| Mapping stories to requirements...                             |
-+--------------------------------------------------------------+
-```
-
-**If a PRD exists (`project-management/prd.md`):**
-1. Map each story to a functional requirement (FR-xxx)
-2. Identify stories without matching requirements (code without spec)
-3. Identify requirements without matching stories (spec without code)
-4. Add `implements: FR-xxx` reference to each mapped story
-
-### Step 5: Output and Validation
-
-```
-+--------------------------------------------------------------+
-|            REVERSE STORIES - COMPLETE                           |
-+--------------------------------------------------------------+
-| Stories generated. Human validation required.                   |
-+--------------------------------------------------------------+
-```
-
-**Actions:**
-1. Save stories to `project-management/backlog/user-stories/`
-2. Generate a summary index of all stories
-3. Present stories grouped by module for user review
-4. Ask user to validate, correct, or reject each story
-
-## Output Format
-
-```
-project-management/
-+-- backlog/
-    +-- user-stories/
-        +-- US-001-create-user.md
-        +-- US-002-list-users.md
-        +-- US-003-update-user.md
-        +-- US-004-create-order.md
-        +-- ...
-```
-
-**Summary Output:**
-
-```
-+==============================================================+
-|              REVERSE-ENGINEERED USER STORIES                   |
-+==============================================================+
-| Total Stories: 18                                              |
-| Status: DRAFT - Requires human validation                      |
-+==============================================================+
-| Module: User                                                   |
-|   US-001: Create user account              [3 pts] [Must]      |
-|   US-002: List users with pagination       [2 pts] [Must]      |
-|   US-003: Update user profile              [2 pts] [Must]      |
-|   US-004: Deactivate user account          [2 pts] [Should]    |
-+--------------------------------------------------------------+
-| Module: Order                                                  |
-|   US-005: Create new order                 [5 pts] [Must]      |
-|   US-006: List orders with filters         [3 pts] [Must]      |
-|   US-007: Update order status              [3 pts] [Must]      |
-|   US-008: Cancel order                     [3 pts] [Should]    |
-+--------------------------------------------------------------+
-| Module: Payment                                                |
-|   US-009: Process payment                  [5 pts] [Must]      |
-|   US-010: Refund payment                   [5 pts] [Should]    |
-+--------------------------------------------------------------+
-| Traceability:                                                  |
-|   Mapped to PRD: 14/18 stories                                 |
-|   Unmapped (code without spec): 4 stories                      |
-+==============================================================+
-```
-
-## Example Session
-
-```
-User: /project:reverse-stories --module=Order
-
-Claude: Starting reverse story generation for module: Order
-
-[Loading Context]
-Loaded scan report: 5 modules, 23 endpoints
-Loaded PRD: 14 functional requirements
-Focusing on module: Order (7 endpoints, 3 entities)
-
-[Feature Extraction]
-Analyzing OrderController... 5 endpoints found
-Analyzing CreateOrderHandler... 3 dependencies, 2 events
-Analyzing Order entity... 15 fields, 4 status transitions
-Analyzing OrderTest... 12 test methods
-
-[Story Generation]
-Generated 6 user stories from Order module:
-- US-005: Create new order (POST /api/orders)
-- US-006: List orders with filters (GET /api/orders)
-- US-007: View order details (GET /api/orders/{id})
-- US-008: Update order status (PATCH /api/orders/{id}/status)
-- US-009: Cancel order (POST /api/orders/{id}/cancel)
-- US-010: Export orders to CSV (GET /api/orders/export)
-
-[Traceability]
-5/6 stories mapped to PRD requirements
-1 story unmapped: US-010 (Export) - no matching FR in PRD
-
-Stories saved to: project-management/backlog/user-stories/
-
-Would you like to:
-1. Review each story for validation?
-2. Generate stories for another module?
-3. Run /project:gap-analysis to find all gaps?
-```
-
-## Related Commands
-
-- `/project:scan` - Scan codebase (prerequisite)
-- `/project:reverse-prd` - Generate PRD from codebase
-- `/project:gap-analysis` - Compare spec vs code
-- `/project:generate-backlog` - Create SCRUM backlog from PRD (greenfield)
-- `/project:update-stories` - Update existing stories
+Run `/project:reverse stories $ARGUMENTS`: read `.claude/commands/project/reverse.md` and follow it with these arguments.