feat(ralph): Add ralph plugin for autonomous PRD implementation

- Add /ralph:prd command for PRD generation with clarifying questions
- Add /ralph:convert command to convert PRD to executable JSON
- Include templates: ralph.sh, prompt.md, prd-template.json
- Include example PRD (prd-hello-api.json)
- Update marketplace.json with ralph plugin v1.0.0
- Update README with ralph documentation

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Claude Agent
2026-01-11 21:37:03 +00:00
parent cb1e95948e
commit 3d52ac696c
10 changed files with 842 additions and 5 deletions

View File

@@ -0,0 +1,142 @@
---
description: Convertește un PRD markdown în format prd.json pentru loop-ul autonom Ralph. Folosește acest skill când utilizatorul are un PRD generat și vrea să-l convertească pentru execuție autonomă cu Ralph.
---
# Skill: Ralph PRD Converter
Convertește un PRD markdown existent în format `prd.json` pentru sistemul Ralph de execuție autonomă.
## Când să folosești acest skill
- Utilizatorul are deja un PRD markdown generat (în `/tasks/prd-*.md`)
- Vrea să pregătească task-urile pentru execuție autonomă cu Ralph
- Sau vrea să inițializeze structura Ralph într-un proiect
## Workflow
### Pas 1: Verifică PRD-ul existent
```bash
ls tasks/prd-*.md
```
Dacă nu există un PRD, sugerează să folosească skill-ul `/ralph:prd` mai întâi.
### Pas 2: Citește PRD-ul și extrage user stories
Citește fișierul PRD și identifică:
- Numele proiectului
- User stories cu acceptance criteria
- Dependențe între stories
### Pas 3: Creează structura Ralph
```bash
mkdir -p scripts/ralph/logs scripts/ralph/archive
```
### Pas 4: Generează prd.json
Convertește user stories în format JSON cu următoarea structură:
```json
{
"projectName": "feature-name",
"branchName": "ralph/feature-name",
"description": "Descriere din PRD",
"userStories": [
{
"id": "US-001",
"title": "Titlu story",
"description": "As a [user], I want [feature] so that [benefit]",
"priority": 1,
"acceptanceCriteria": [
"Criteriu specific și verificabil",
"npm run typecheck passes"
],
"passes": false,
"notes": ""
}
]
}
```
### Pas 5: Validează mărimea stories
**CRITIC**: Fiecare story trebuie să fie completabil într-un singur context window.
#### Story de mărime corectă:
- Adaugă un câmp în baza de date
- Creează un component UI simplu
- Adaugă un endpoint API
- Scrie tests pentru o funcție specifică
#### Story prea mare (trebuie spart):
- "Implementează autentificarea completă"
- "Creează dashboard-ul admin"
- "Adaugă sistem de notificări end-to-end"
Dacă găsești stories prea mari, sparge-le în sub-stories mai mici.
### Pas 6: Setează prioritățile
Ordinea recomandată:
1. Schema/Database changes (priority: 1-10)
2. Backend logic (priority: 11-20)
3. API endpoints (priority: 21-30)
4. UI components (priority: 31-40)
5. Integration/polish (priority: 41-50)
Stories care depind de altele trebuie să aibă prioritate mai mare (număr mai mare).
### Pas 7: Verifică acceptance criteria
Fiecare story TREBUIE să aibă:
- Criterii specifice și verificabile (NU vagi ca "funcționează bine")
- `npm run typecheck passes` (sau echivalent)
- Pentru UI: `Verify in browser that [specific behavior]`
### Pas 8: Copiază fișierele Ralph
Dacă nu există deja, copiază template-urile din plugin:
- `scripts/ralph/ralph.sh` - scriptul principal (din templates/ralph.sh)
- `scripts/ralph/prompt.md` - instrucțiunile per iterație (din templates/prompt.md)
### Pas 9: Inițializează progress.txt
```bash
echo "# Ralph Progress Log" > scripts/ralph/progress.txt
echo "Started: $(date)" >> scripts/ralph/progress.txt
echo "Project: [project-name]" >> scripts/ralph/progress.txt
echo "---" >> scripts/ralph/progress.txt
```
### Pas 10: Instrucțiuni finale
După completare, informează utilizatorul:
```
PRD convertit în scripts/ralph/prd.json
Pentru a rula Ralph:
cd [project-directory]
./scripts/ralph/ralph.sh [max_iterations]
Monitorizare:
cat scripts/ralph/prd.json | jq '.userStories[] | {id, title, passes}'
cat scripts/ralph/progress.txt
```
## Output așteptat
- `scripts/ralph/prd.json` - task-urile în format JSON
- `scripts/ralph/progress.txt` - log inițializat
- Structura de directoare completă
## Reguli importante
1. **NU începe implementarea** - acest skill doar convertește PRD-ul
2. **Validează mărimea stories** - sparge-le dacă sunt prea mari
3. **Prioritizează corect** - dependențele trebuie respectate
4. **Criterii verificabile** - nu vagi, ci specifice
5. **Inițializează `passes: false`** pentru toate stories

View File

@@ -0,0 +1,194 @@
---
description: Generează un Product Requirements Document (PRD) structurat pentru o funcționalitate nouă. Folosește acest skill când utilizatorul vrea să planifice și documenteze cerințele pentru un feature înainte de implementare.
---
# Skill: PRD Generator
Generează un Product Requirements Document (PRD) detaliat pentru funcționalități noi prin întrebări clarificatoare și documentație structurată.
## Când să folosești acest skill
- Utilizatorul vrea să adauge o funcționalitate nouă
- Vrea să planifice înainte de a implementa
- Menționează "PRD", "requirements", "cerințe", "planifică feature"
## Workflow
### Pas 1: Întrebări de clarificare
Înainte de a genera PRD-ul, pune 3-5 întrebări pentru a înțelege scopul:
```markdown
Pentru a genera un PRD bun, am câteva întrebări:
**A) Care este scopul principal?**
1. Funcționalitate nouă pentru utilizatori
2. Îmbunătățire performanță/scalabilitate
3. Refactoring/cleanup cod existent
4. Integrare cu sistem extern
**B) Cine sunt utilizatorii țintă?**
1. End users (clienți finali)
2. Admin/Staff intern
3. Developers (API/SDK)
4. Sistem automatizat
**C) Ce constrângeri tehnice există?**
1. Trebuie să folosească framework/librărie existentă
2. Fără dependențe externe noi
3. Compatibilitate backwards necesară
4. Flexibil
**D) Care e prioritatea?**
1. Urgent (blocant pentru release)
2. Important (următorul sprint)
3. Nice-to-have (când e timp)
**E) Ai specificații vizuale sau mockups?**
1. Da, am wireframes/mockups
2. Am idee generală în minte
3. Flexibil, propune tu
```
### Pas 2: Generează PRD-ul
După răspunsuri, creează documentul în `/tasks/prd-[feature-name].md`:
```markdown
# PRD: [Feature Name]
## 1. Introducere
[Context și motivație pentru feature - 2-3 propoziții]
## 2. Obiective
### Obiectiv Principal
- [Ce problem rezolvă]
### Obiective Secundare
- [Beneficii adiționale]
### Metrici de Succes
- [Cum măsurăm dacă e reușit]
## 3. User Stories
### US-001: [Titlu Descriptiv]
**Ca** [tip utilizator]
**Vreau** [funcționalitate]
**Pentru că** [beneficiu]
**Acceptance Criteria:**
- [ ] Criteriu 1 specific și testabil
- [ ] Criteriu 2 specific și testabil
- [ ] npm run typecheck passes
- [ ] [Pentru UI] Verify in browser that [comportament specific]
### US-002: [Titlu]
...
## 4. Cerințe Funcționale
1. [REQ-001] Sistemul trebuie să...
2. [REQ-002] Utilizatorul poate să...
3. [REQ-003] Când X se întâmplă, Y trebuie să...
## 5. Non-Goals (Ce NU facem)
- [Explicit ce nu e în scope pentru a evita scope creep]
- [Funcționalități similare care NU sunt incluse]
## 6. Considerații Tehnice
### Stack/Tehnologii
- [Ce framework/librării se folosesc]
### Patterns de Urmat
- [Patterns existente în codebase]
### Dependențe
- [De ce depinde acest feature]
### Riscuri Tehnice
- [Potențiale probleme]
## 7. Considerații UI/UX
[Dacă e relevant]
- Layout și flow
- Stări (loading, error, empty, success)
- Accesibilitate
## 8. Success Metrics
- [KPI 1]: [target]
- [KPI 2]: [target]
## 9. Open Questions
- [ ] [Întrebări nerezolvate care necesită clarificare]
```
### Pas 3: Validare cu utilizatorul
După generare, întreabă:
- "PRD-ul acoperă tot ce ai în minte?"
- "Vrei să adaugi sau să modifici ceva?"
- "Stories-urile sunt de mărime potrivită pentru implementare incrementală?"
### Pas 4: Salvare
```bash
# Crează directorul tasks dacă nu există
mkdir -p tasks
# Salvează PRD-ul
# Folosește kebab-case pentru nume
```
### Pas 5: Sugerează următorul pas
```markdown
PRD salvat în tasks/prd-[feature-name].md
**Următorii pași:**
1. Revizuiește PRD-ul și adaugă detalii dacă e nevoie
2. Când ești gata, folosește `/ralph:convert` pentru a converti în prd.json
3. Apoi rulează `./scripts/ralph/ralph.sh` pentru implementare autonomă
```
## Reguli pentru User Stories bune
### Mărime potrivită (1 context window):
- Adaugă un câmp în DB + migration
- Creează un component React simplu
- Implementează un endpoint API
- Scrie unit tests pentru o funcție
### Prea mare (trebuie spart):
- "Implementează autentificarea" → sparge în: login form, register form, JWT middleware, session management
- "Creează dashboard" → sparge în: layout, charts component, data fetching, filtering
### Ordine dependențe:
1. Database/Schema (nu depind de nimic)
2. Backend logic (depind de schema)
3. API endpoints (depind de backend)
4. UI components (depind de API)
5. Integration (depind de toate)
### Acceptance Criteria:
- Specifice: "Butonul Submit trimite form data la POST /api/users"
- NU vagi: "Funcționează corect"
- Verificabile: "După submit, redirect la /dashboard"
- NU subiective: "UX plăcut"
- Include ÎNTOTDEAUNA: "npm run typecheck passes"
- Pentru UI: "Verify in browser that [behavior]"
## Output așteptat
- Fișier `/tasks/prd-[feature-name].md` cu documentație completă
- User stories clare, atomice, cu acceptance criteria verificabile
- Non-goals explicit definite
## Important
1. **NU începe implementarea** - acest skill doar generează documentație
2. **Întreabă clarificări** înainte de a genera
3. **Stories atomice** - fiecare trebuie să fie independent completabil
4. **Acceptance criteria verificabile** - nu vagi
5. **Kebab-case** pentru nume fișiere