Add Ralph skill for autonomous PRD creation and implementation

skills/ralph/README.md

@@ -0,0 +1,261 @@
+# Ralph Plugin
+
+**Ralph** este un loop autonom de agent AI care rulează Claude Code în mod repetat până când toate task-urile dintr-un PRD sunt complete.
+
+Adaptat din [snarktank/ralph](https://github.com/snarktank/ralph) pentru Claude Code CLI, cu îmbunătățiri inspirate din [coleam00/ai-agents-masterclass](https://github.com/coleam00/ai-agents-masterclass).
+
+## Comenzi disponibile
+
+| Comandă | Descriere |
+|---------|-----------|
+| `/ralph:prd` | Generează PRD structurat cu detecție context și întrebări adaptive |
+| `/ralph:convert` | Convertește PRD markdown în prd.json și configurează proiectul |
+
+## Features
+
+### Detecție Automată Context
+- Detectează automat tech stack-ul din fișierele de config (package.json, pyproject.toml, etc.)
+- Adaptează întrebările: ~10 pentru proiecte noi vs ~5-7 pentru features în proiecte existente
+- Extrage comenzile reale din proiect (npm scripts, etc.)
+
+### Întrebări Interactive
+- Folosește `AskUserQuestion` pentru UX interactiv (nu text simplu)
+- Web research opțional pentru best practices (WebSearch)
+- Întrebări adaptive bazate pe context detectat
+
+### Verificare Vizuală Browser
+- Folosește **agent-browser CLI** pentru verificări UI
+- Snapshots compacte cu referințe (@e1, @e2) - eficiente cu tokeni
+- Screenshots salvate automat pentru referință
+
+### Configurare Automată
+- Generează `.claude/settings.json` cu allow-list per tech stack
+- Actualizează prompt.md cu comenzile reale ale proiectului
+- Arhivare automată a rulărilor anterioare
+
+## Workflow
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                      WORKFLOW RALPH                          │
+├─────────────────────────────────────────────────────────────┤
+│  1. /ralph:prd                                               │
+│     ├─ Detectează context proiect (existent vs nou)         │
+│     ├─ Pune întrebări adaptive cu AskUserQuestion           │
+│     ├─ (Opțional) WebSearch pentru best practices           │
+│     └─ Generează PRD în /tasks/prd-*.md                     │
+│                                                              │
+│  2. /ralph:convert                                           │
+│     ├─ Detectează tech stack și comenzi                     │
+│     ├─ Generează .claude/settings.json (allow-list)         │
+│     ├─ Copiază și configurează scripts/ralph/               │
+│     └─ Creează prd.json cu techStack info                   │
+│                                                              │
+│  3. ./scripts/ralph/ralph.sh [max_iterations]               │
+│     ├─ Selectează story cu prioritate minimă                │
+│     ├─ Lansează Claude Code (context curat)                 │
+│     ├─ Implementează + quality checks                       │
+│     ├─ Verificare browser pentru UI (agent-browser)         │
+│     ├─ Commit + marchează passes: true                      │
+│     └─ Repetă până toate complete                           │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Cerințe
+
+### Obligatorii
+- **Claude Code CLI** instalat și autentificat
+- **jq** pentru procesare JSON
+- **Git** repository
+
+### Recomandate (pentru verificări UI)
+- **agent-browser** - pentru verificări vizuale browser
+  ```bash
+  npm install -g agent-browser && agent-browser install
+  ```
+
+## Utilizare
+
+### Pas 1: Generează PRD
+
+```
+/ralph:prd
+
+Vreau să adaug funcționalitate de export CSV pentru dashboard.
+```
+
+Claude va:
+1. Detecta dacă există proiect (package.json, etc.)
+2. Pune întrebări adaptive:
+   - Proiect nou: ~10 întrebări (stack, arhitectură, UI, auth, etc.)
+   - Feature în proiect existent: ~5-7 întrebări (tip, UI, DB, security)
+3. Opțional: WebSearch pentru best practices
+4. Genera PRD în `/tasks/prd-export-csv.md`
+
+### Pas 2: Convertește în JSON
+
+```
+/ralph:convert
+
+Convertește PRD-ul din tasks/prd-export-csv.md
+```
+
+Claude va:
+1. Detecta tech stack și extrage comenzile din package.json/etc.
+2. Genera `.claude/settings.json` cu allow-list
+3. Crea structura `scripts/ralph/` cu fișierele configurate
+4. Genera `prd.json` cu techStack info
+
+### Pas 3: Rulează Ralph
+
+```bash
+./scripts/ralph/ralph.sh 20  # 20 iterații max
+```
+
+### Pas 4: Monitorizare
+
+```bash
+# Status stories
+jq '.userStories[] | {id, title, passes}' scripts/ralph/prd.json
+
+# Progress log
+cat scripts/ralph/progress.txt
+
+# Screenshots UI
+ls scripts/ralph/screenshots/
+```
+
+## Structura proiectului
+
+După `/ralph:convert`:
+
+```
+your-project/
+├── .claude/
+│   └── settings.json     # Permissions allow-list (generat)
+├── scripts/ralph/
+│   ├── ralph.sh          # Script principal
+│   ├── prompt.md         # Instrucțiuni per iterație (cu comenzi reale)
+│   ├── prd.json          # Task-uri cu techStack (generat)
+│   ├── progress.txt      # Learnings (generat)
+│   ├── logs/             # Logs per iterație
+│   ├── archive/          # Arhive rulări anterioare
+│   └── screenshots/      # Screenshots verificări UI
+└── tasks/
+    └── prd-*.md          # PRD-uri markdown
+```
+
+## Format prd.json
+
+```json
+{
+  "projectName": "feature-name",
+  "branchName": "ralph/feature-name",
+  "description": "Descriere feature",
+  "techStack": {
+    "type": "nextjs",
+    "commands": {
+      "start": "npm run dev",
+      "build": "npm run build",
+      "lint": "npm run lint",
+      "typecheck": "npm run typecheck",
+      "test": "npm test"
+    },
+    "port": 3000
+  },
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "Titlu story",
+      "description": "As a user...",
+      "priority": 1,
+      "acceptanceCriteria": ["..."],
+      "requiresBrowserCheck": true,
+      "passes": false,
+      "notes": ""
+    }
+  ]
+}
+```
+
+## Verificare Browser cu agent-browser
+
+Pentru stories cu UI (`requiresBrowserCheck: true`), Ralph folosește **agent-browser CLI**:
+
+```bash
+# Navighează
+agent-browser navigate "http://localhost:3000"
+
+# Snapshot (referințe compacte @e1, @e2, etc.)
+agent-browser snapshot
+
+# Interacțiuni
+agent-browser click @e5
+agent-browser fill @e3 "value"
+
+# Screenshot
+agent-browser screenshot ./scripts/ralph/screenshots/US-001.png
+
+# Console errors
+agent-browser console
+```
+
+**De ce agent-browser (nu Playwright MCP):**
+- Referințe compacte (@e1, @e2) - consum minim tokeni
+- Fiecare iterație Ralph are context limitat
+- CLI simplu, fără server MCP
+- Optimizat pentru agenți AI
+
+## Reguli pentru stories bune
+
+### Mărime corectă (1 context window)
+- Adaugă un câmp în DB + migration
+- Creează un component UI simplu
+- Adaugă un endpoint API
+- Scrie tests pentru o funcție
+
+### Ordinea priorităților
+1. Schema/Database (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)
+
+### Acceptance Criteria
+- Specifice și verificabile
+- Include comanda typecheck reală din proiect
+- Pentru UI: "Verificare vizuală browser că [behavior]"
+
+## settings.json Auto-Generate
+
+Per tech stack detectat:
+
+**Next.js/TypeScript:**
+```json
+{
+  "permissions": {
+    "allow": [
+      "npm run dev", "npm run build", "npm run lint",
+      "npm run typecheck", "npx prisma *", "npm test"
+    ]
+  }
+}
+```
+
+**Python/FastAPI:**
+```json
+{
+  "permissions": {
+    "allow": [
+      "uvicorn * --reload", "python -m pytest",
+      "ruff check .", "mypy .", "alembic *"
+    ]
+  }
+}
+```
+
+## Credite
+
+- [snarktank/ralph](https://github.com/snarktank/ralph) - Ralph original pentru Amp
+- [coleam00/ai-agents-masterclass](https://github.com/coleam00/ai-agents-masterclass) - Inspirație pentru îmbunătățiri
+- [vercel-labs/agent-browser](https://github.com/vercel-labs/agent-browser) - Browser CLI pentru verificări UI

skills/ralph/SKILL.md

@@ -0,0 +1,206 @@
+---
+name: ralph
+description: Autonomous PRD creation and conversion for Claude Code autonomous loops - context detection, adaptive questions, browser verification
+metadata:
+  {
+    "openclaw": { "emoji": "🔄", "requires": { "anyBins": ["claude", "jq", "git"] } },
+  }
+---
+
+# Ralph - Autonomous Loop for PRD Implementation
+
+**Ralph** este un sistem pentru crearea și execuția autonomă a Product Requirements Documents (PRD) cu Claude Code.
+
+Adaptat din [snarktank/ralph](https://github.com/snarktank/ralph) pentru Claude Code CLI, cu îmbunătățiri inspirate din [coleam00/ai-agents-masterclass](https://github.com/coleam00/ai-agents-masterclass).
+
+## Comenzi disponibile
+
+| Comandă | Descriere |
+|---------|-----------|
+| `/ralph:prd` | Generează PRD structurat cu detecție context și întrebări adaptive |
+| `/ralph:convert` | Convertește PRD markdown în prd.json și configurează proiectul |
+
+## Features
+
+### Detecție Automată Context
+- Detectează automat tech stack-ul din fișierele de config (package.json, pyproject.toml, etc.)
+- Adaptează întrebările: ~10 pentru proiecte noi vs ~5-7 pentru features în proiecte existente
+- Extrage comenzile reale din proiect (npm scripts, etc.)
+
+### Întrebări Interactive
+- Folosește `AskUserQuestion` pentru UX interactiv (nu text simplu)
+- Web research opțional pentru best practices (WebSearch)
+- Întrebări adaptive bazate pe context detectat
+
+### Verificare Vizuală Browser
+- Folosește **agent-browser CLI** pentru verificări UI
+- Snapshots compacte cu referințe (@e1, @e2) - eficiente cu tokeni
+- Screenshots salvate automat pentru referință
+
+### Configurare Automată
+- Generează `.claude/settings.json` cu allow-list per tech stack
+- Actualizează prompt.md cu comenzile reale ale proiectului
+- Arhivare automată a rulărilor anterioare
+
+## Workflow
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                      WORKFLOW RALPH                          │
+├─────────────────────────────────────────────────────────────┤
+│  1. /ralph:prd                                               │
+│     ├─ Detectează context proiect (existent vs nou)         │
+│     ├─ Pune întrebări adaptive cu AskUserQuestion           │
+│     ├─ (Opțional) WebSearch pentru best practices           │
+│     └─ Generează PRD în /tasks/prd-*.md                     │
+│                                                              │
+│  2. /ralph:convert                                           │
+│     ├─ Detectează tech stack și comenzi                     │
+│     ├─ Generează .claude/settings.json (allow-list)         │
+│     ├─ Copiază și configurează scripts/ralph/               │
+│     └─ Creează prd.json cu techStack info                   │
+│                                                              │
+│  3. ./scripts/ralph/ralph.sh [max_iterations]               │
+│     ├─ Selectează story cu prioritate minimă                │
+│     ├─ Lansează Claude Code (context curat)                 │
+│     ├─ Implementează + quality checks                       │
+│     ├─ Verificare browser pentru UI (agent-browser)         │
+│     ├─ Commit + marchează passes: true                      │
+│     └─ Repetă până toate complete                           │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Când să folosești acest skill
+
+### Folosește `/ralph:prd` când:
+- Utilizatorul vrea să adauge o funcționalitate nouă
+- Vrea să planifice înainte de a implementa
+- Menționează "PRD", "requirements", "cerințe", "planifică feature"
+
+### Folosește `/ralph:convert` când:
+- 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
+
+## Cerințe
+
+### Obligatorii
+- **Claude Code CLI** instalat și autentificat
+- **jq** pentru procesare JSON
+- **Git** repository
+
+### Recomandate (pentru verificări UI)
+- **agent-browser** - pentru verificări vizuale browser
+  ```bash
+  npm install -g agent-browser && agent-browser install
+  ```
+
+## Utilizare rapidă
+
+### Pas 1: Generează PRD
+
+Invocă skill-ul și descrie feature-ul:
+
+```
+/ralph:prd
+
+Vreau să adaug funcționalitate de export CSV pentru dashboard.
+```
+
+Claude va detecta contextul, pune întrebări adaptive și genera PRD-ul.
+
+### Pas 2: Convertește în JSON
+
+```
+/ralph:convert
+
+Convertește PRD-ul din tasks/prd-export-csv.md
+```
+
+### Pas 3: Rulează Ralph
+
+```bash
+./scripts/ralph/ralph.sh 20  # 20 iterații max
+```
+
+## Structura proiectului
+
+După `/ralph:convert`:
+
+```
+your-project/
+├── .claude/
+│   └── settings.json     # Permissions allow-list (generat)
+├── scripts/ralph/
+│   ├── ralph.sh          # Script principal
+│   ├── prompt.md         # Instrucțiuni per iterație (cu comenzi reale)
+│   ├── prd.json          # Task-uri cu techStack (generat)
+│   ├── progress.txt      # Learnings (generat)
+│   ├── logs/             # Logs per iterație
+│   ├── archive/          # Arhive rulări anterioare
+│   └── screenshots/      # Screenshots verificări UI
+└── tasks/
+    └── prd-*.md          # PRD-uri markdown
+```
+
+## Instrucțiuni pentru Agent
+
+Când utilizatorul invocă `/ralph:prd` sau `/ralph:convert`:
+
+1. **Citește documentația specifică comenzii** din `commands/prd.md` sau `commands/convert.md`
+2. **Urmează workflow-ul exact** din documentație
+3. **Folosește template-urile** din `templates/` când este necesar
+4. **Salvează output-ul** în locația corectă (`tasks/` pentru PRD, `scripts/ralph/` pentru conversie)
+
+## Format prd.json
+
+```json
+{
+  "projectName": "feature-name",
+  "branchName": "ralph/feature-name",
+  "description": "Descriere feature",
+  "techStack": {
+    "type": "nextjs",
+    "commands": {
+      "start": "npm run dev",
+      "build": "npm run build",
+      "lint": "npm run lint",
+      "typecheck": "npm run typecheck",
+      "test": "npm test"
+    },
+    "port": 3000
+  },
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "Titlu story",
+      "description": "As a user...",
+      "priority": 1,
+      "acceptanceCriteria": ["..."],
+      "requiresBrowserCheck": true,
+      "passes": false,
+      "notes": ""
+    }
+  ]
+}
+```
+
+## Verificare Browser cu agent-browser
+
+Pentru stories cu UI (`requiresBrowserCheck: true`), Ralph folosește **agent-browser CLI** pentru verificări vizuale eficiente.
+
+## Credite
+
+- [snarktank/ralph](https://github.com/snarktank/ralph) - Ralph original pentru Amp
+- [coleam00/ai-agents-masterclass](https://github.com/coleam00/ai-agents-masterclass) - Inspirație pentru îmbunătățiri
+- [vercel-labs/agent-browser](https://github.com/vercel-labs/agent-browser) - Browser CLI pentru verificări UI
+
+## Template Files Location
+
+Template-urile pentru acest skill sunt în:
+- `templates/prompt.md` - Instrucțiuni pentru fiecare iterație Ralph
+- `templates/ralph.sh` - Script-ul principal de execuție
+- `templates/prd-template.json` - Template JSON pentru PRD
+- `commands/prd.md` - Documentație detaliată pentru `/ralph:prd`
+- `commands/convert.md` - Documentație detaliată pentru `/ralph:convert`
+- `examples/` - Exemple de PRD-uri generate

skills/ralph/commands/convert.md

@@ -0,0 +1,361 @@
+---
+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: Detectează Tech Stack
+
+**Verifică fișierele de config pentru a determina stack-ul:**
+
+```
+package.json       → Node.js/JavaScript
+pyproject.toml     → Python
+go.mod             → Go
+Cargo.toml         → Rust
+pom.xml            → Java
+```
+
+**Extrage comenzi din config:**
+
+Pentru `package.json`:
+```javascript
+// Citește scripts section:
+{
+  "scripts": {
+    "dev": "next dev",           // → START_COMMAND
+    "build": "next build",       // → BUILD_COMMAND
+    "lint": "eslint .",          // → LINT_COMMAND
+    "typecheck": "tsc --noEmit"  // → TYPECHECK_COMMAND
+  }
+}
+```
+
+**Mapare comenzi standard:**
+
+| Stack | Start | Build | Lint | Typecheck |
+|-------|-------|-------|------|-----------|
+| Next.js | npm run dev | npm run build | npm run lint | npm run typecheck |
+| Node/Express | npm start | npm run build | npm run lint | npm run typecheck |
+| Python/FastAPI | uvicorn main:app --reload | - | ruff check . | mypy . |
+| Go | go run . | go build | golangci-lint run | - |
+| Rust | cargo run | cargo build | cargo clippy | - |
+
+### Pas 4: Creează structura Ralph
+
+```bash
+mkdir -p scripts/ralph/logs scripts/ralph/archive scripts/ralph/screenshots
+```
+
+### Pas 5: Generează .claude/settings.json
+
+**IMPORTANT**: Generează configurația pentru permissions allow-list bazat pe tech stack detectat.
+
+```bash
+mkdir -p .claude
+```
+
+**Template settings.json per stack:**
+
+#### Next.js / TypeScript:
+```json
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm run dev)",
+      "Bash(npm run build)",
+      "Bash(npm run lint)",
+      "Bash(npm run typecheck)",
+      "Bash(npx prisma:*)",
+      "Bash(npm test)",
+      "Bash(npm run test:*)"
+    ]
+  }
+}
+```
+
+#### Node.js / Express:
+```json
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm start)",
+      "Bash(npm run dev)",
+      "Bash(npm run build)",
+      "Bash(npm run lint)",
+      "Bash(npm test)",
+      "Bash(npm run test:*)"
+    ]
+  }
+}
+```
+
+#### Python / FastAPI:
+```json
+{
+  "permissions": {
+    "allow": [
+      "Bash(uvicorn:*)",
+      "Bash(python -m pytest:*)",
+      "Bash(pytest:*)",
+      "Bash(ruff check:*)",
+      "Bash(ruff format:*)",
+      "Bash(mypy:*)",
+      "Bash(pip install:*)",
+      "Bash(alembic:*)"
+    ]
+  }
+}
+```
+
+#### Go:
+```json
+{
+  "permissions": {
+    "allow": [
+      "Bash(go run:*)",
+      "Bash(go build:*)",
+      "Bash(go test:*)",
+      "Bash(golangci-lint:*)",
+      "Bash(go mod:*)"
+    ]
+  }
+}
+```
+
+#### Generic (fără config detectat):
+```json
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm run:*)",
+      "Bash(npm test)",
+      "Bash(npm start)"
+    ]
+  }
+}
+```
+
+**Verifică și merging:**
+- Dacă `.claude/settings.json` există deja, citește-l și merge permissions
+- Nu suprascrie setări existente, doar adaugă cele lipsă
+
+### Pas 6: 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",
+  "techStack": {
+    "type": "nextjs",
+    "commands": {
+      "start": "npm run dev",
+      "build": "npm run build",
+      "lint": "npm run lint",
+      "typecheck": "npm run typecheck",
+      "test": "npm test"
+    },
+    "port": 3000
+  },
+  "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"
+      ],
+      "requiresBrowserCheck": true,
+      "passes": false,
+      "notes": ""
+    }
+  ]
+}
+```
+
+**Câmpuri noi:**
+- `techStack` - informații despre stack-ul detectat
+- `techStack.commands` - comenzile reale din proiect
+- `techStack.port` - portul pentru dev server
+- `requiresBrowserCheck` - true dacă story-ul are UI
+
+### Pas 7: 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 8: 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 9: Verifică acceptance criteria
+
+Fiecare story TREBUIE să aibă:
+- Criterii specifice și verificabile (NU vagi ca "funcționează bine")
+- Comanda reală de typecheck: `{TYPECHECK_COMMAND} passes`
+- Pentru UI: `Verificare vizuală browser: [specific behavior]`
+
+### Pas 10: Copiază template-urile Ralph din plugin
+
+**IMPORTANT**: Copiază fișierele template direct din plugin pentru a asigura consistența.
+
+**Execută următoarele comenzi:**
+
+```bash
+# Găsește locația plugin-ului Ralph
+RALPH_PLUGIN=$(find /workspace -type f -name "ralph.sh" -path "*/plugins/ralph/templates/*" 2>/dev/null | head -1 | xargs dirname 2>/dev/null)
+
+# Verifică că plugin-ul a fost găsit
+if [ -z "$RALPH_PLUGIN" ]; then
+    echo "EROARE: Nu am găsit plugin-ul Ralph în /workspace"
+    echo "Asigură-te că claude-plugins este clonat în /workspace"
+    exit 1
+fi
+
+echo "Plugin Ralph găsit în: $RALPH_PLUGIN"
+
+# Copiază template-urile
+cp "$RALPH_PLUGIN/prompt.md" scripts/ralph/
+cp "$RALPH_PLUGIN/ralph.sh" scripts/ralph/
+chmod +x scripts/ralph/ralph.sh
+
+echo "Template-uri copiate din plugin"
+```
+
+**Dacă plugin-ul NU este găsit:**
+- Informează utilizatorul că trebuie să cloneze `claude-plugins` în `/workspace`
+- Sau să specifice manual locația plugin-ului
+
+**NU genera fișierele manual** - copiază-le întotdeauna din plugin pentru a păstra consistența și a beneficia de actualizări.
+
+### Pas 11: 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 "Stack: [detected-stack]" >> scripts/ralph/progress.txt
+echo "---" >> scripts/ralph/progress.txt
+```
+
+### Pas 12: Verificare finală
+
+**Verifică că toate fișierele sunt create:**
+
+```
+scripts/ralph/
+├── ralph.sh          # Script principal
+├── prompt.md         # Instrucțiuni (cu comenzi reale)
+├── prd.json          # Task-uri și status
+├── progress.txt      # Log inițializat
+├── logs/             # Director pentru logs
+├── archive/          # Director pentru arhivare
+└── screenshots/      # Director pentru verificări vizuale
+
+.claude/
+└── settings.json     # Permissions allow-list
+```
+
+### Pas 13: Instrucțiuni finale
+
+După completare, informează utilizatorul:
+
+```
+PRD convertit în scripts/ralph/prd.json
+
+Structură creată:
+  scripts/ralph/        - Fișiere Ralph
+  scripts/ralph/screenshots/  - Pentru verificări vizuale
+  .claude/settings.json - Permissions pentru comenzi
+
+Tech stack detectat: {stack}
+Comenzi configurate:
+  Start:     {START_COMMAND}
+  Build:     {BUILD_COMMAND}
+  Typecheck: {TYPECHECK_COMMAND}
+  Lint:      {LINT_COMMAND}
+  Test:      {TEST_COMMAND}
+
+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
+
+IMPORTANT:
+  - Ralph va folosi agent-browser pentru verificări vizuale UI
+  - Screenshots se salvează în scripts/ralph/screenshots/
+  - Asigură-te că ai agent-browser instalat: npm install -g agent-browser && agent-browser install
+```
+
+## Output așteptat
+
+- `scripts/ralph/prd.json` - task-urile în format JSON cu tech stack info
+- `scripts/ralph/progress.txt` - log inițializat
+- `scripts/ralph/prompt.md` - copiat din plugin (single source of truth)
+- `scripts/ralph/ralph.sh` - copiat din plugin (single source of truth)
+- `scripts/ralph/screenshots/` - director pentru verificări vizuale
+- `.claude/settings.json` - permissions allow-list pentru tech stack
+- Structura de directoare completă
+
+## Reguli importante
+
+1. **NU începe implementarea** - acest skill doar convertește PRD-ul
+2. **Detectează tech stack** - pentru comenzi și settings.json
+3. **Validează mărimea stories** - sparge-le dacă sunt prea mari
+4. **Prioritizează corect** - dependențele trebuie respectate
+5. **Criterii verificabile** - nu vagi, ci specifice
+6. **Inițializează `passes: false`** pentru toate stories
+7. **Generează settings.json** - pentru allow-list permissions
+8. **COPIAZĂ template-urile din plugin** - NU le genera manual, folosește `find` pentru a localiza plugin-ul și copiază `prompt.md` și `ralph.sh` din templates/

skills/ralph/commands/prd.md

@@ -0,0 +1,462 @@
+---
+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 prin detecție automată a contextului și întrebări adaptive.
+
+## 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
+
+### FAZA 1: Detecție Context Proiect
+
+**Verifică existența fișierelor de config pentru a determina modul:**
+
+```
+package.json       → Node.js/JavaScript ecosystem
+pyproject.toml     → Python
+requirements.txt   → Python (legacy)
+go.mod             → Go
+Cargo.toml         → Rust
+pom.xml            → Java (Maven)
+build.gradle       → Java (Gradle)
+composer.json      → PHP
+Gemfile            → Ruby
+```
+
+**DACĂ găsit config file:**
+1. Citește fișierul de config pentru a extrage:
+   - Dependențe principale (framework-uri, librării)
+   - Scripturi disponibile (pentru package.json)
+   - Versiuni
+2. Analizează structura directoarelor:
+   - `src/`, `app/`, `components/`, `pages/`, `api/`
+   - Identifică patterns: Next.js, React, Express, etc.
+3. Raportează utilizatorului:
+   ```
+   Am detectat un proiect existent:
+   - Stack: Next.js 14, TypeScript, Prisma, TailwindCSS
+   - Structură: App Router (app/), API routes (app/api/)
+   - Scripts: dev, build, lint, typecheck
+   ```
+4. Setează: **FEATURE_MODE**
+
+**DACĂ NU găsit config file:**
+1. Raportează: "Nu am detectat un proiect existent. Vom crea PRD pentru proiect nou."
+2. Setează: **NEW_PROJECT_MODE**
+
+---
+
+### FAZA 2: Întrebări Adaptive cu AskUserQuestion
+
+**IMPORTANT**: Folosește tool-ul `AskUserQuestion` pentru întrebări interactive, NU text simplu.
+
+---
+
+#### IF NEW_PROJECT_MODE:
+
+**Întrebarea 1** (AskUserQuestion):
+```json
+{
+  "question": "Ce tip de proiect vrei să creezi?",
+  "header": "Tip proiect",
+  "options": [
+    {"label": "Web Application", "description": "Frontend + Backend, UI interactiv"},
+    {"label": "API / Backend", "description": "REST/GraphQL API, servicii backend"},
+    {"label": "CLI Tool", "description": "Command-line application"},
+    {"label": "Library / SDK", "description": "Cod reutilizabil pentru alți developeri"}
+  ],
+  "multiSelect": false
+}
+```
+
+**Întrebarea 2** (AskUserQuestion):
+```json
+{
+  "question": "Cine sunt utilizatorii țintă?",
+  "header": "Audiență",
+  "options": [
+    {"label": "End users", "description": "Clienți finali, public larg"},
+    {"label": "Developers", "description": "API/SDK consumers, tehnici"},
+    {"label": "Admin / Staff", "description": "Utilizatori interni, back-office"},
+    {"label": "Sistem automatizat", "description": "Integrări machine-to-machine"}
+  ],
+  "multiSelect": false
+}
+```
+
+**Întrebarea 3** (AskUserQuestion):
+```json
+{
+  "question": "Ce tech stack preferi?",
+  "header": "Stack",
+  "options": [
+    {"label": "Next.js + TypeScript (Recommended)", "description": "Full-stack React, App Router, API routes"},
+    {"label": "Node.js + Express", "description": "Backend flexibil, REST API"},
+    {"label": "Python + FastAPI", "description": "API modern, async, type hints"},
+    {"label": "Go", "description": "Performance, simplitate, concurrency"}
+  ],
+  "multiSelect": false
+}
+```
+
+**Întrebarea 4** (AskUserQuestion):
+```json
+{
+  "question": "Ce arhitectură de date preferi?",
+  "header": "Database",
+  "options": [
+    {"label": "PostgreSQL + Prisma (Recommended)", "description": "Relațional, ORM type-safe"},
+    {"label": "MongoDB", "description": "Document store, schema flexibilă"},
+    {"label": "SQLite", "description": "Simplitate, embedded, local-first"},
+    {"label": "Fără persistență", "description": "In-memory, stateless"}
+  ],
+  "multiSelect": false
+}
+```
+
+**Întrebarea 5** (AskUserQuestion):
+```json
+{
+  "question": "Cum va arăta interfața?",
+  "header": "UI/UX",
+  "options": [
+    {"label": "Dashboard / Admin Panel", "description": "Tabele, grafice, forms complexe"},
+    {"label": "Landing + App simplu", "description": "Marketing + funcționalitate core"},
+    {"label": "API only (no UI)", "description": "Doar backend, documentație API"},
+    {"label": "CLI interface", "description": "Terminal-based interaction"}
+  ],
+  "multiSelect": false
+}
+```
+
+**Întrebarea 6** (AskUserQuestion):
+```json
+{
+  "question": "Ce tip de autentificare e necesar?",
+  "header": "Auth",
+  "options": [
+    {"label": "Email + Password", "description": "Classic login, JWT sessions"},
+    {"label": "OAuth / Social login", "description": "Google, GitHub, etc."},
+    {"label": "API Keys", "description": "Pentru servicii și integrări"},
+    {"label": "Fără autentificare", "description": "Public access"}
+  ],
+  "multiSelect": true
+}
+```
+
+**Întrebarea 7** (AskUserQuestion):
+```json
+{
+  "question": "Ce integrări externe sunt necesare?",
+  "header": "Integrări",
+  "options": [
+    {"label": "Payment (Stripe)", "description": "Procesare plăți, subscriptions"},
+    {"label": "Email (Resend/SendGrid)", "description": "Trimitere emails tranzacționale"},
+    {"label": "Storage (S3/Cloudflare)", "description": "Upload fișiere, imagini"},
+    {"label": "Niciuna", "description": "Self-contained, fără dependențe externe"}
+  ],
+  "multiSelect": true
+}
+```
+
+**Întrebarea 8** (AskUserQuestion):
+```json
+{
+  "question": "Care e prioritatea acestui proiect?",
+  "header": "Prioritate",
+  "options": [
+    {"label": "MVP rapid", "description": "Funcționalitate minimă, lansare rapidă"},
+    {"label": "Produs complet", "description": "Feature-complete, production-ready"},
+    {"label": "Proof of concept", "description": "Validare idee, poate fi refăcut"},
+    {"label": "Learning project", "description": "Experimentare, nu contează calitatea"}
+  ],
+  "multiSelect": false
+}
+```
+
+**Întrebarea 9** (AskUserQuestion):
+```json
+{
+  "question": "Cum definim succesul? Ce criterii trebuie îndeplinite?",
+  "header": "Success",
+  "options": [
+    {"label": "Funcționalitate completă", "description": "Toate features funcționează conform spec"},
+    {"label": "Performance targets", "description": "Timp răspuns < X ms, throughput > Y"},
+    {"label": "User adoption", "description": "N utilizatori activi, engagement"},
+    {"label": "Code quality", "description": "Test coverage > 80%, no critical bugs"}
+  ],
+  "multiSelect": true
+}
+```
+
+**Întrebarea 10** (text liber - cere descriere):
+```
+Descrie pe scurt proiectul în 2-3 propoziții:
+- Ce problemă rezolvă?
+- Care e funcționalitatea principală?
+```
+
+**Întrebarea 11 - Web Research** (AskUserQuestion):
+```json
+{
+  "question": "Vrei să cercetez best practices și patterns pentru acest stack?",
+  "header": "Research",
+  "options": [
+    {"label": "Da, cercetează", "description": "WebSearch pentru patterns și recomandări"},
+    {"label": "Nu, continuă", "description": "Am experiență cu acest stack"}
+  ],
+  "multiSelect": false
+}
+```
+
+**DACĂ utilizatorul alege "Da, cercetează":**
+- Folosește `WebSearch` pentru: "[stack] best practices 2026"
+- Integrează findings în secțiunea "Considerații Tehnice" din PRD
+
+---
+
+#### IF FEATURE_MODE:
+
+**Întrebarea 1** (text liber):
+```
+Descrie feature-ul pe care vrei să-l adaugi:
+- Ce funcționalitate nouă?
+- Care e scopul principal?
+```
+
+**Întrebarea 2** (AskUserQuestion):
+```json
+{
+  "question": "Ce tip de feature este acesta?",
+  "header": "Tip feature",
+  "options": [
+    {"label": "Funcționalitate nouă", "description": "Ceva ce nu există în app"},
+    {"label": "Îmbunătățire UX", "description": "Flow mai bun, mai intuitiv"},
+    {"label": "Performance", "description": "Optimizare viteză, eficiență"},
+    {"label": "Integrare externă", "description": "Conectare cu alt sistem/serviciu"}
+  ],
+  "multiSelect": false
+}
+```
+
+**Întrebarea 3** (AskUserQuestion):
+```json
+{
+  "question": "Implică modificări de UI?",
+  "header": "UI changes",
+  "options": [
+    {"label": "Da - componente noi", "description": "Pagini sau secțiuni noi"},
+    {"label": "Da - modificări existente", "description": "Update la UI existent"},
+    {"label": "Nu - doar backend", "description": "Logic, API, fără UI"}
+  ],
+  "multiSelect": false
+}
+```
+
+**Întrebarea 4** (AskUserQuestion):
+```json
+{
+  "question": "Necesită modificări în baza de date?",
+  "header": "DB changes",
+  "options": [
+    {"label": "Da - tabele noi", "description": "Noi entități de stocat"},
+    {"label": "Da - coloane noi", "description": "Câmpuri noi pe tabele existente"},
+    {"label": "Da - relații noi", "description": "Legături între tabele"},
+    {"label": "Nu", "description": "Schema rămâne neschimbată"}
+  ],
+  "multiSelect": true
+}
+```
+
+**Întrebarea 5** (AskUserQuestion):
+```json
+{
+  "question": "Sunt necesare integrări noi cu servicii externe?",
+  "header": "Integrări",
+  "options": [
+    {"label": "Da - API extern", "description": "Conectare la serviciu terț"},
+    {"label": "Da - Webhooks", "description": "Primire/trimitere events"},
+    {"label": "Nu", "description": "Self-contained în app"}
+  ],
+  "multiSelect": true
+}
+```
+
+**Întrebarea 6** (AskUserQuestion):
+```json
+{
+  "question": "Există considerații speciale de security?",
+  "header": "Security",
+  "options": [
+    {"label": "Autorizare/permisiuni", "description": "Cine poate accesa ce"},
+    {"label": "Date sensibile", "description": "PII, payment, credentials"},
+    {"label": "Rate limiting", "description": "Protecție abuse"},
+    {"label": "Nu, standard", "description": "Fără cerințe speciale"}
+  ],
+  "multiSelect": true
+}
+```
+
+**Întrebarea 7** (text liber):
+```
+Cum verificăm că feature-ul funcționează corect?
+Descrie acceptance criteria (ce trebuie să se întâmple când e gata):
+```
+
+---
+
+### FAZA 3: 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 bazate pe răspunsuri]
+
+## 2. Context Tehnic
+[DOAR pentru FEATURE_MODE - include stack-ul detectat]
+- **Stack**: [detectat din config]
+- **Structură**: [detectat din directoare]
+- **Comenzi disponibile**: [din package.json scripts]
+
+## 3. Obiective
+### Obiectiv Principal
+- [Ce problemă rezolvă - din răspunsuri]
+
+### Obiective Secundare
+- [Beneficii adiționale]
+
+### Metrici de Succes
+- [Din răspunsul la întrebarea despre success criteria]
+
+## 4. User Stories
+
+### US-001: [Titlu Descriptiv]
+**Ca** [tip utilizator - din răspunsuri]
+**Vreau** [funcționalitate]
+**Pentru că** [beneficiu]
+
+**Acceptance Criteria:**
+- [ ] Criteriu 1 specific și testabil
+- [ ] Criteriu 2 specific și testabil
+- [ ] {TYPECHECK_COMMAND} passes
+- [ ] [Pentru UI] Verificare vizuală cu browser: [comportament specific]
+
+### US-002: [Titlu]
+...
+
+## 5. 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ă...
+
+## 6. Non-Goals (Ce NU facem)
+- [Explicit ce nu e în scope pentru a evita scope creep]
+- [Funcționalități similare care NU sunt incluse]
+
+## 7. Considerații Tehnice
+### Stack/Tehnologii
+- [Din detecție sau răspunsuri]
+
+### Patterns de Urmat
+- [Patterns existente în codebase - din analiză]
+
+### Dependențe
+- [De ce depinde acest feature]
+
+### Riscuri Tehnice
+- [Potențiale probleme]
+
+### Best Practices
+[Dacă s-a făcut WebSearch, include findings aici]
+
+## 8. Considerații UI/UX
+[Dacă UI changes != "Nu - doar backend"]
+- Layout și flow
+- Stări (loading, error, empty, success)
+- Accesibilitate
+
+## 9. Considerații Security
+[Din răspunsul la întrebarea despre security]
+
+## 10. Open Questions
+- [ ] [Întrebări nerezolvate care necesită clarificare]
+```
+
+---
+
+### FAZA 4: Validare și salvare
+
+1. **Afișează preview** al PRD-ului generat
+2. **Întreabă** utilizatorul:
+   - "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ă?"
+3. **Salvează** în `/tasks/prd-[feature-name].md`
+4. **Sugerează următorul pas**:
+   ```
+   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 comanda de typecheck din proiect
+- Pentru UI: "Verificare vizuală cu browser că [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
+- Context tehnic detectat (pentru FEATURE_MODE)
+
+## Important
+
+1. **NU începe implementarea** - acest skill doar generează documentație
+2. **Folosește AskUserQuestion** pentru întrebări interactive
+3. **Detectează contextul** înainte de a pune întrebări
+4. **Stories atomice** - fiecare trebuie să fie independent completabil
+5. **Acceptance criteria verificabile** - nu vagi
+6. **Kebab-case** pentru nume fișiere

skills/ralph/examples/prd-hello-api.json

@@ -0,0 +1,59 @@
+{
+  "projectName": "hello-api",
+  "branchName": "ralph/hello-api",
+  "description": "Un API simplu de test pentru a demonstra funcționarea Ralph",
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "Inițializare proiect Node.js",
+      "description": "Ca developer, vreau un proiect Node.js inițializat pentru a avea baza de cod",
+      "priority": 1,
+      "acceptanceCriteria": [
+        "package.json există cu name și version",
+        "Folosește ES modules (type: module)",
+        "Fișierul index.js există și poate fi rulat"
+      ],
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-002",
+      "title": "Endpoint GET /hello",
+      "description": "Ca utilizator, vreau un endpoint care returnează un salut",
+      "priority": 2,
+      "acceptanceCriteria": [
+        "GET /hello returnează JSON cu mesaj",
+        "Status code 200",
+        "Content-Type application/json"
+      ],
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-003",
+      "title": "Endpoint POST /echo",
+      "description": "Ca utilizator, vreau un endpoint care returnează ce îi trimit",
+      "priority": 3,
+      "acceptanceCriteria": [
+        "POST /echo acceptă JSON body",
+        "Returnează același body înapoi",
+        "Status 400 dacă body invalid"
+      ],
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-004",
+      "title": "Tests pentru endpoints",
+      "description": "Ca developer, vreau tests pentru a verifica funcționalitatea",
+      "priority": 4,
+      "acceptanceCriteria": [
+        "Test pentru GET /hello",
+        "Test pentru POST /echo",
+        "npm test rulează cu succes"
+      ],
+      "passes": false,
+      "notes": ""
+    }
+  ]
+}

skills/ralph/templates/prd-template.json

@@ -0,0 +1,19 @@
+{
+  "projectName": "feature-name",
+  "branchName": "ralph/feature-name",
+  "description": "Descriere scurtă a feature-ului",
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "Titlu story",
+      "description": "As a [user type], I want [feature] so that [benefit]",
+      "priority": 1,
+      "acceptanceCriteria": [
+        "Criteriu specific și verificabil",
+        "npm run typecheck passes"
+      ],
+      "passes": false,
+      "notes": ""
+    }
+  ]
+}

skills/ralph/templates/prompt.md

@@ -0,0 +1,207 @@
+# Ralph - Instrucțiuni pentru Iterație
+
+Ești un agent autonom care implementează user stories dintr-un PRD. Aceasta este O SINGURĂ iterație - implementezi UN singur story și apoi te oprești.
+
+## Workflow pentru această iterație
+
+### 1. Citește contextul
+- PRD-ul și progress.txt sunt furnizate în context
+- Înțelege ce stories sunt deja complete (`passes: true`)
+- Identifică următorul story de implementat (prioritate cea mai mică dintre cele incomplete)
+- Notează `techStack.commands` din PRD pentru comenzile corecte
+
+### 2. Management branch
+- Verifică dacă ești pe branch-ul corect (specificat în `branchName` din PRD)
+- Dacă nu, creează și checkout branch-ul:
+  ```bash
+  git checkout -b <branchName>
+  ```
+- Dacă branch-ul există deja, doar checkout:
+  ```bash
+  git checkout <branchName>
+  ```
+
+### 3. Selectează story-ul
+- Alege story-ul cu cea mai mică prioritate care are `passes: false`
+- Citește atent acceptance criteria
+- Verifică câmpul `requiresBrowserCheck` - dacă e `true`, trebuie verificare vizuală
+
+### 4. Implementare
+- Implementează DOAR acest story
+- Urmează patterns existente în codebase
+- Fii minimal și focusat - nu adăuga funcționalități extra
+
+### 5. Quality Checks
+Rulează TOATE verificările înainte de commit. Folosește comenzile din `techStack.commands`:
+
+```bash
+# Folosește comenzile din prd.json techStack.commands:
+{techStack.commands.typecheck}   # Type checking
+{techStack.commands.lint}        # Linting
+{techStack.commands.test}        # Tests (dacă există)
+```
+
+**Comenzi standard per stack:**
+
+| Stack | Typecheck | Lint | Test |
+|-------|-----------|------|------|
+| Next.js/TS | npm run typecheck | npm run lint | npm test |
+| Node.js | npm run typecheck | npm run lint | npm test |
+| Python | mypy . | ruff check . | python -m pytest |
+| Go | - | golangci-lint run | go test ./... |
+
+**IMPORTANT**: Nu face commit dacă verificările eșuează. Repară mai întâi.
+
+### 6. Verificare Browser (pentru UI stories)
+
+**DACĂ story-ul are `requiresBrowserCheck: true` sau implică UI:**
+
+Folosește **agent-browser CLI** pentru verificare vizuală. Agent-browser e optimizat pentru agenți AI cu referințe compacte (@e1, @e2) care consumă minim tokeni.
+
+#### 6.1 Pornește dev server-ul
+```bash
+# Folosește comanda din techStack.commands.start
+{techStack.commands.start}
+# Exemplu: npm run dev
+```
+
+Așteaptă să pornească (verifică output-ul pentru "ready" sau similar).
+
+#### 6.2 Navighează la pagină
+```bash
+agent-browser navigate "http://localhost:{techStack.port}"
+# Exemplu: agent-browser navigate "http://localhost:3000"
+```
+
+#### 6.3 Ia snapshot pentru verificare
+```bash
+agent-browser snapshot
+```
+
+Snapshot-ul returnează o listă de elemente cu referințe compacte:
+```
+@e1: heading "Welcome"
+@e2: button "Login"
+@e3: textbox "Email"
+@e4: textbox "Password"
+@e5: button "Submit"
+```
+
+**Verifică în snapshot:**
+- Elementele cheie din acceptance criteria există
+- Textul e corect
+- Structura paginii e corectă
+
+#### 6.4 Testează interacțiunile (dacă e cazul)
+```bash
+# Click pe un element
+agent-browser click @e2
+
+# Fill un input
+agent-browser fill @e3 "test@example.com"
+
+# Așteaptă o schimbare
+agent-browser snapshot  # verifică noua stare
+```
+
+#### 6.5 Salvează screenshot ca dovadă
+```bash
+agent-browser screenshot ./scripts/ralph/screenshots/US-{id}-$(date +%Y%m%d-%H%M%S).png
+# Exemplu: agent-browser screenshot ./scripts/ralph/screenshots/US-001-20240115-143022.png
+```
+
+#### 6.6 Verifică erori
+```bash
+# Verifică console pentru erori
+agent-browser console
+```
+
+**IMPORTANT**:
+- NU marca story-ul complete dacă verificarea vizuală eșuează!
+- Dacă găsești erori în browser, repară-le înainte de commit
+- Screenshots sunt salvate în `scripts/ralph/screenshots/` pentru referință
+
+### 7. Documentare (dacă ai descoperit ceva util)
+Dacă ai descoperit patterns sau gotchas, actualizează `AGENTS.md` în directorul relevant:
+- API patterns
+- Dependențe non-evidente
+- Convenții de cod
+- Cum să testezi anumite funcționalități
+
+### 8. Commit
+Format commit message:
+```
+feat: [Story ID] - [Story Title]
+```
+
+### 9. Marchează story-ul ca complet
+**CRITIC**: Actualizează `scripts/ralph/prd.json`:
+- Setează `passes: true` pentru story-ul implementat
+- Adaugă note relevante în câmpul `notes`
+
+### 10. Actualizează progress.txt
+Adaugă la sfârșitul fișierului `scripts/ralph/progress.txt`:
+
+```markdown
+## Iterație: [timestamp]
+### Story implementat: [ID] - [Title]
+### Status: Complete
+
+### Verificări:
+- Typecheck: PASS
+- Lint: PASS
+- Tests: PASS/SKIP
+- Browser check: PASS/N/A
+
+### Learnings:
+- [Ce ai învățat]
+- [Patterns descoperite]
+
+### Next steps:
+- [Ce rămâne de făcut]
+---
+```
+
+## Reguli importante
+
+1. **UN SINGUR STORY PE ITERAȚIE** - Nu implementa mai mult de un story
+2. **TOATE CHECKS TREBUIE SĂ TREACĂ** - Nu face commit cu erori
+3. **VERIFICARE BROWSER PENTRU UI** - Obligatorie dacă `requiresBrowserCheck: true`
+4. **ACTUALIZEAZĂ prd.json** - Altfel iterația următoare va repeta munca
+5. **FII CONCIS** - Nu over-engineer
+
+## Comenzi agent-browser (referință rapidă)
+
+```bash
+# Navigare
+agent-browser navigate "http://localhost:3000/page"
+
+# Snapshot (vedere compactă a paginii)
+agent-browser snapshot
+
+# Click pe element (folosind ref din snapshot)
+agent-browser click @e5
+
+# Fill input
+agent-browser fill @e3 "value"
+
+# Screenshot
+agent-browser screenshot ./path/to/file.png
+
+# Console logs
+agent-browser console
+
+# Așteaptă text
+agent-browser wait-for "Loading complete"
+```
+
+## Condiție de terminare
+
+Dacă TOATE stories au `passes: true`, răspunde cu:
+
+```
+<promise>COMPLETE</promise>
+```
+
+---
+ÎNCEPE IMPLEMENTAREA ACUM.

skills/ralph/templates/ralph.sh

@@ -0,0 +1,193 @@
+#!/bin/bash
+# Ralph pentru Claude Code - Loop autonom de agent AI
+# Adaptat din Ralph original (snarktank/ralph) pentru Claude Code CLI
+# Usage: ./ralph.sh [max_iterations] [project_dir]
+
+set -e
+
+MAX_ITERATIONS=${1:-10}
+PROJECT_DIR=${2:-$(pwd)}
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PRD_FILE="$SCRIPT_DIR/prd.json"
+PROGRESS_FILE="$SCRIPT_DIR/progress.txt"
+ARCHIVE_DIR="$SCRIPT_DIR/archive"
+SCREENSHOTS_DIR="$SCRIPT_DIR/screenshots"
+LAST_BRANCH_FILE="$SCRIPT_DIR/.last-branch"
+PROMPT_FILE="$SCRIPT_DIR/prompt.md"
+
+# Verifică că jq este instalat
+if ! command -v jq &> /dev/null; then
+    echo "Eroare: jq nu este instalat. Rulează: apt install jq"
+    exit 1
+fi
+
+# Verifică că claude este instalat
+if ! command -v claude &> /dev/null; then
+    echo "Eroare: Claude Code CLI nu este instalat."
+    echo "Instalează cu: npm install -g @anthropic-ai/claude-code"
+    exit 1
+fi
+
+# Verifică agent-browser (opțional, pentru verificări UI)
+if ! command -v agent-browser &> /dev/null; then
+    echo "Notă: agent-browser nu este instalat."
+    echo "Pentru verificări vizuale UI, instalează cu: npm install -g agent-browser && agent-browser install"
+    echo "Continuăm fără verificări browser..."
+    echo ""
+fi
+
+# Verifică existența fișierelor necesare
+if [ ! -f "$PRD_FILE" ]; then
+    echo "Eroare: prd.json nu există în $SCRIPT_DIR"
+    echo "Generează mai întâi un PRD folosind skill-ul /prd și apoi /ralph"
+    exit 1
+fi
+
+if [ ! -f "$PROMPT_FILE" ]; then
+    echo "Eroare: prompt.md nu există în $SCRIPT_DIR"
+    exit 1
+fi
+
+# Arhivare rulare anterioară dacă branch-ul s-a schimbat
+if [ -f "$PRD_FILE" ] && [ -f "$LAST_BRANCH_FILE" ]; then
+  CURRENT_BRANCH=$(jq -r '.branchName // empty' "$PRD_FILE" 2>/dev/null || echo "")
+  LAST_BRANCH=$(cat "$LAST_BRANCH_FILE" 2>/dev/null || echo "")
+
+  if [ -n "$CURRENT_BRANCH" ] && [ -n "$LAST_BRANCH" ] && [ "$CURRENT_BRANCH" != "$LAST_BRANCH" ]; then
+    DATE=$(date +%Y-%m-%d)
+    FOLDER_NAME=$(echo "$LAST_BRANCH" | sed 's|^ralph/||')
+    ARCHIVE_FOLDER="$ARCHIVE_DIR/$DATE-$FOLDER_NAME"
+
+    echo "Arhivare rulare anterioară: $LAST_BRANCH"
+    mkdir -p "$ARCHIVE_FOLDER"
+    [ -f "$PRD_FILE" ] && cp "$PRD_FILE" "$ARCHIVE_FOLDER/"
+    [ -f "$PROGRESS_FILE" ] && cp "$PROGRESS_FILE" "$ARCHIVE_FOLDER/"
+    echo "   Arhivat în: $ARCHIVE_FOLDER"
+
+    # Reset progress file
+    echo "# Ralph Progress Log" > "$PROGRESS_FILE"
+    echo "Started: $(date)" >> "$PROGRESS_FILE"
+    echo "Branch: $CURRENT_BRANCH" >> "$PROGRESS_FILE"
+    echo "---" >> "$PROGRESS_FILE"
+  fi
+fi
+
+# Salvează branch-ul curent
+if [ -f "$PRD_FILE" ]; then
+  CURRENT_BRANCH=$(jq -r '.branchName // empty' "$PRD_FILE" 2>/dev/null || echo "")
+  if [ -n "$CURRENT_BRANCH" ]; then
+    echo "$CURRENT_BRANCH" > "$LAST_BRANCH_FILE"
+  fi
+fi
+
+# Creează directoare necesare
+mkdir -p "$SCRIPT_DIR/logs" "$SCRIPT_DIR/archive" "$SCRIPT_DIR/screenshots"
+
+# Inițializare progress file dacă nu există
+if [ ! -f "$PROGRESS_FILE" ]; then
+  echo "# Ralph Progress Log" > "$PROGRESS_FILE"
+  echo "Started: $(date)" >> "$PROGRESS_FILE"
+  echo "---" >> "$PROGRESS_FILE"
+fi
+
+# Funcție pentru a verifica dacă toate story-urile sunt complete
+check_all_complete() {
+  local incomplete=$(jq '[.userStories[] | select(.passes != true)] | length' "$PRD_FILE" 2>/dev/null || echo "999")
+  [ "$incomplete" -eq 0 ]
+}
+
+# Afișare status inițial
+echo ""
+echo "======================================================================="
+echo "       RALPH pentru Claude Code - Agent Autonom                        "
+echo "======================================================================="
+PROJECT_NAME=$(jq -r '.projectName // "Unknown"' "$PRD_FILE")
+BRANCH_NAME=$(jq -r '.branchName // "N/A"' "$PRD_FILE")
+TOTAL_STORIES=$(jq '.userStories | length' "$PRD_FILE")
+COMPLETE_STORIES=$(jq '[.userStories[] | select(.passes == true)] | length' "$PRD_FILE")
+echo "  Proiect: $PROJECT_NAME"
+echo "  Branch: $BRANCH_NAME"
+echo "  Stories: $COMPLETE_STORIES / $TOTAL_STORIES complete"
+echo "  Max iterații: $MAX_ITERATIONS"
+echo "  Screenshots: $SCREENSHOTS_DIR"
+echo "======================================================================="
+echo ""
+
+# Verificare rapidă - poate toate sunt deja complete?
+if check_all_complete; then
+  echo "Toate story-urile sunt deja complete!"
+  exit 0
+fi
+
+# Loop principal
+for i in $(seq 1 $MAX_ITERATIONS); do
+  echo ""
+  echo "==================================================================="
+  echo "  Ralph Iterația $i din $MAX_ITERATIONS"
+  echo "==================================================================="
+
+  # Status curent
+  COMPLETE_NOW=$(jq '[.userStories[] | select(.passes == true)] | length' "$PRD_FILE")
+  NEXT_STORY=$(jq -r '[.userStories[] | select(.passes != true)] | sort_by(.priority) | .[0] | "\(.id): \(.title)"' "$PRD_FILE")
+  echo "  Progress: $COMPLETE_NOW / $TOTAL_STORIES stories complete"
+  echo "  Next: $NEXT_STORY"
+  echo ""
+
+  # Pregătește prompt-ul cu context
+  FULL_PROMPT=$(cat <<EOF
+# Context pentru această iterație Ralph
+
+## PRD (prd.json):
+$(cat "$PRD_FILE")
+
+## Progress până acum (progress.txt):
+$(cat "$PROGRESS_FILE")
+
+## Instrucțiuni pentru această iterație:
+$(cat "$PROMPT_FILE")
+EOF
+)
+
+  # Execută Claude Code în modul non-interactiv
+  LOG_FILE="$SCRIPT_DIR/logs/iteration-$i-$(date +%Y%m%d-%H%M%S).log"
+  mkdir -p "$SCRIPT_DIR/logs"
+
+  # --output-format json avoids streaming mode issues
+  echo "$FULL_PROMPT" | claude -p --dangerously-skip-permissions --output-format json 2>&1 | tee "$LOG_FILE" || true
+  OUTPUT=$(cat "$LOG_FILE")
+
+  # Verifică dacă toate task-urile sunt complete
+  if echo "$OUTPUT" | grep -q "<promise>COMPLETE</promise>"; then
+    echo ""
+    echo "==================================================================="
+    echo "  RALPH A TERMINAT TOATE TASK-URILE!"
+    echo "  Completat la iterația $i din $MAX_ITERATIONS"
+    echo "==================================================================="
+    exit 0
+  fi
+
+  # Verifică și prin prd.json
+  if check_all_complete; then
+    echo ""
+    echo "==================================================================="
+    echo "  TOATE STORY-URILE DIN PRD SUNT COMPLETE!"
+    echo "==================================================================="
+    exit 0
+  fi
+
+  echo "  Iterația $i completă. Continuăm..."
+  sleep 2
+done
+
+echo ""
+echo "==================================================================="
+echo "  Ralph a atins limita de iterații ($MAX_ITERATIONS)"
+echo "  Verifică progress.txt pentru status."
+echo "==================================================================="
+echo ""
+
+# Afișează stories incomplete
+echo "Stories incomplete:"
+jq -r '.userStories[] | select(.passes != true) | "  - \(.id): \(.title)"' "$PRD_FILE"
+
+exit 1