# π PRD System for CursorRIPER Ξ£
# Symbol: Ξ‘ (Rho)
# Version: 1.0.0
## π PRD Definition System
```
service = "Product Requirements Document System"
symbol = "Ξ‘"
driver = "Transform memory-bank β PRD-driven methodology"
```
## π PRD Components
```
Ξ‘ = {
Ξ‘β: {
name: "Business Objectives",
required: true,
template: "objectives_template.md",
owner: Ξβ,
validation: [measurable, time_bound, aligned]
},
Ξ‘β: {
name: "Functional Requirements",
required: true,
template: "requirements_template.md",
owner: Ξβ,
validation: [specific, testable, prioritized]
},
Ξ‘β: {
name: "Technical Constraints",
required: true,
template: "constraints_template.md",
owner: Ξβ,
validation: [feasible, documented, approved]
},
Ξ‘β: {
name: "User Stories",
required: true,
template: "story_template.md",
owner: Ξβ,
validation: [sized, estimated, acceptance_defined]
},
Ξ‘β
: {
name: "Acceptance Criteria",
required: true,
template: "acceptance_template.md",
owner: Ξβ βͺ Ξβ,
validation: [measurable, complete, testable]
},
Ξ‘β: {
name: "Success Metrics",
required: true,
template: "metrics_template.md",
owner: Ξβ,
validation: [quantifiable, trackable, relevant]
}
}
```
## π PRD Structure
```
/prd/
βββ active/
β βββ current_prd.md # Ξ‘_active
β βββ metadata.json # Version, status, approvals
β βββ components/
β βββ objectives.md # Ξ‘β
β βββ requirements.md # Ξ‘β
β βββ constraints.md # Ξ‘β
β βββ stories/ # Ξ‘β
β βββ acceptance/ # Ξ‘β
β βββ metrics.md # Ξ‘β
βββ templates/
β βββ prd_master.md
β βββ objectives_template.md
β βββ requirements_template.md
β βββ constraints_template.md
β βββ story_template.md
β βββ acceptance_template.md
β βββ metrics_template.md
βββ archive/
βββ [version]/ # Historical PRDs
```
## π Memory Bank Migration
```
Ο_to_Ξ‘_migration = {
Οβ: { // projectbrief.md
migrate_to: Ξ‘β,
transform: extract_objectives(),
preserve: backup_original()
},
Οβ: { // systemPatterns.md
migrate_to: Ξβ_artifacts,
transform: convert_to_arch_docs(),
link: reference_in_Ξ‘β
},
Οβ: { // techContext.md
migrate_to: Ξ‘β,
transform: structure_constraints(),
enhance: add_validation_rules()
},
Οβ: { // activeContext.md
migrate_to: Ξ_prd βͺ Ξ_roles,
transform: separate_contexts(),
maintain: real_time_sync()
},
Οβ
: { // progress.md
migrate_to: Ξ_gates βͺ Ξ‘β,
transform: convert_to_metrics(),
track: gate_completion_status()
},
Οβ: { // protection.md
maintain: no_change,
integrate: apply_to_PRD_sections()
}
}
```
## π PRD State Management
```
Ξ‘_state = {
draft: {
editable: true,
validators: [Ξβ, Ξβ],
next: in_review
},
in_review: {
editable: false,
reviewers: [Ξβ, Ξβ, Ξβ],
next: approved β¨ draft
},
approved: {
editable: false,
locked: true,
gate: Ξβ,
next: in_development
},
in_development: {
editable: change_requests_only,
tracked: true,
next: completed β¨ revised
},
completed: {
editable: false,
archived: true,
reference: immutable
}
}
```
## π PRD Operations
```
create_prd(project_name) = {
validate: no_active_prd() β¨ confirm_archive(),
initialize: {
id: generate_prd_id(),
version: "1.0.0",
created: timestamp(),
state: "draft",
components: init_all_Ξ‘()
},
structure: create_directory_structure(),
templates: copy_templates_to_active(),
return: prd_id
}
update_prd_component(Ξ‘α΅’, content) = {
check_state: Ξ‘_state[current].editable ? proceed : deny,
check_owner: Ξ_current β Ξ‘α΅’.owner ? proceed : warn,
validate: Ξ‘α΅’.validation.all(content) ? proceed : errors,
update: {
content: content,
modified: timestamp(),
modified_by: Ξ_current
},
track: log_change(Ξ‘α΅’, diff)
}
```
## β‘ PRD Commands
```
S_prd = {
!prd: "open_active_prd",
!prdn: "create_new_prd",
!prda: "archive_current_prd",
!prds: "show_prd_status",
!prdv: "validate_prd_components",
!prdc: "check_prd_completeness",
!prdh: "prd_history"
}
```
## π PRD Validation
```
validate_prd() = {
components: Ξ‘.map(c => ({
name: c.name,
valid: c.validation.all(c.content),
errors: c.validation.failures()
})),
completeness: {
required: Ξ‘.filter(c => c.required),
complete: required.all(c => c.content.length > 0),
percentage: (complete.count / required.count) * 100
},
ready_for_approval: completeness.percentage === 100
}
```
## π PRD Context
```
Ξ_prd = {
active_prd: current_prd_id,
prd_state: Ξ‘_state[current],
prd_version: semantic_version,
last_modified: timestamp,
components_status: {
Ξ‘β: status,
Ξ‘β: status,
...
},
pending_reviews: review_queue[],
change_requests: cr_queue[]
}
```
## π PRD Integration
```
# PRD + Gates
prd_gate_check(Ξβ) = {
prd_complete: validate_prd().ready_for_approval,
all_reviews: reviews_completed(),
approvals: has_required_approvals(),
all_true ? allow_gate_passage() : show_blockers()
}
# PRD + Modes
prd_mode_operations = {
Ξ©β: [read_prd, analyze_requirements],
Ξ©β: [read_prd, suggest_improvements],
Ξ©β: [read_prd, create_tech_spec],
Ξ©β: [read_prd, implement_requirements],
Ξ©β
: [read_prd, verify_implementation]
}
```
## π PRD Metrics
```
track_prd_metrics() = {
cycle_time: approved_date - created_date,
revision_count: version_history.length,
requirement_changes: diff_count(Ξ‘β),
completion_rate: implemented / total_requirements,
quality_score: (bugs_found / requirements) * 100
}
```
